python

modo interactivo
El modo interactivo en Python se refiere a la capacidad de ejecutar comandos de Python de
manera interactiva, línea por línea, en lugar de escribir un script completo y luego ejecutarlo.
Puedes ingresar y ejecutar comandos de Python directamente en el intérprete interactivo de
Python, que se activa al abrir la terminal o la consola y escribir `python` o `python3`
(dependiendo de tu configuración) seguido de presionar Enter.

Cuando trabajas en el modo interactivo, puedes ingresar una línea de código, presionar Enter y
ver el resultado inmediatamente. Esto es útil para realizar pruebas rápidas, experimentar con
pequeñas porciones de código, o simplemente explorar características del lenguaje de
programación.

Por ejemplo, si abres el intérprete interactivo, podrías hacer algo como esto:

```python
>>> x = 5
>>> y = 10
>>> suma = x + y
>>> print(suma)
```

En este caso, cada línea se ejecuta inmediatamente después de presionar Enter, y puedes ver
el resultado paso a paso.

El modo interactivo también es útil para explorar módulos, funciones y clases sin tener que
escribir un script completo. Simplemente importas un módulo y luego puedes llamar a sus
funciones o explorar sus atributos de inmediato.

Para salir del modo interactivo, puedes escribir `exit()` o `quit()`, o puedes presionar Ctrl + D (o
Ctrl + Z en Windows) para salir y volver a la terminal o consola normal.

En resumen, el modo interactivo en Python te permite interactuar directamente con el intérprete

de Python, ejecutando y probando código línea por línea.

cadena cruda (raw string en inglés).

En Python, la cadena de caracteres precedida por `r` se conoce como una cadena de texto
cruda o cadena cruda (raw string en inglés). Esta notación se utiliza para indicar que los
caracteres de escape dentro de la cadena deben tratarse literalmente, sin interpretar ningún
carácter de escape.

En el ejemplo que proporcionaste:

```python
print(r'C:\some\name')
```

La letra `r` antes de la comilla simple indica que la cadena debe considerarse "cruda". En las
cadenas de texto crudas, los caracteres de escape, como `\n` o `\t`, no se interpretan como
saltos de línea o tabulaciones respectivamente. En lugar de eso, la barra invertida se trata
como un carácter literal y se imprime tal cual.

En este caso, la cadena se imprimirá exactamente como está escrita:

```
C:\some\name
```

Este enfoque es útil cuando estás trabajando con rutas de archivo en sistemas Windows,
donde las barras invertidas (`\`) se utilizan como separadores de directorios. Al usar cadenas
crudas, evitas la necesidad de duplicar las barras invertidas para evitar que se interpreten como
caracteres de escape.

Print
La función `print` se utiliza para imprimir información en la consola o en otro flujo de salida.
Aquí hay algunos aspectos adicionales que podrían ser de interés:

1. **Formato de cadenas con `print`:**

Puedes formatear las cadenas que imprimes utilizando el operador de formato `%` o el
método `format()`. Aunque estas formas son un poco antiguas, todavía son comunes en el
código existente:

```python
name = "Juan"
age = 25
print("Hola, %s. Tienes %d años." % (name, age))
 ```

Alternativamente, con el método `format()`:

```python
print("Hola, {}. Tienes {} años.".format(name, age))
```

A partir de Python 3.6, se introdujo una nueva forma de formateo de cadenas llamada "f-
strings":

```python
print(f"Hola, {name}. Tienes {age} años.")
```

2. **Imprimir en la misma línea:**

Por defecto, cada llamada a `print` agrega una nueva línea al final. Puedes evitar esto usando
el argumento `end`:

```python
print("Hola", end=" ")
print("Mundo")
# Salida: Hola Mundo
```

3. **Redirección de la salida:**
Puedes redirigir la salida a un archivo en lugar de la consola. Por ejemplo, para escribir en un
archivo:

```python
with open("archivo.txt", "w") as f:
print("Hola, Mundo!", file=f)
```

4. **Impresión de múltiples valores:**

Puedes imprimir múltiples valores en una sola llamada a `print` separándolos con comas:

```python
x=5
y = 10
print("El valor de x es", x, "y el valor de y es", y)
```

O usando f-strings:
 ```python
print(f"El valor de x es {x} y el valor de y es {y}")
```

5. **Impresión de variables con tipos de datos diversos:**

Puedes imprimir variables de diferentes tipos en la misma llamada a `print`. Python convertirá
automáticamente los valores a cadenas:

```python
nombre = "María"
edad = 30
estatura = 1.75
print("Nombre:", nombre, "Edad:", edad, "Estatura:", estatura)
```
Estos son algunos conceptos adicionales relacionados con la función `print` en Python. ¿Hay
algo en particular en lo que te gustaría profundizar?

Loops

for

funciones y conceptos integrados en con bucles

`for`.
Aquí hay algunos de ellos:

range
1. **`range()`**: Crea una secuencia de números que se pueden utilizar en bucles. Es
comúnmente usado con `for` para iterar sobre un rango de valores.

```python
for i in range(5):
print(i)
```
enumerate
2. **`enumerate()`**: Ya mencionada anteriormente, esta función devuelve tuplas que contienen
el índice y el valor del elemento correspondiente en una secuencia.

```python
mi_lista = ['a', 'b', 'c']
for indice, valor in enumerate(mi_lista):
print(f"Índice: {indice}, Valor: {valor}")
```

zip
3. **`zip()`**: Combina elementos de dos o más secuencias en tuplas. Es útil cuando se desea
iterar sobre varias listas al mismo tiempo.

```python
lista1 = [1, 2, 3]
lista2 = ['a', 'b', 'c']
for num, letra in zip(lista1, lista2):
print(f"Número: {num}, Letra: {letra}")
```

sorted
4. **`sorted()`**: Ordena los elementos de una secuencia y devuelve una nueva lista ordenada.
Puede ser útil cuando necesitas procesar elementos en un orden específico.

```python
for elemento in sorted(mi_lista):
print(elemento)
```

Filter map
5. **`filter()` y `map()`**: Estas funciones pueden usarse con bucles `for` para filtrar o
transformar elementos de una secuencia.

```python
# Ejemplo con filter
numeros = [1, 2, 3, 4, 5]
impares = filter(lambda x: x % 2 != 0, numeros)
for impar in impares:
print(impar)
```

```python
# Ejemplo con map
 cuadrados = map(lambda x: x ** 2, numeros)
for cuadrado in cuadrados:
print(cuadrado)
```

Estas son solo algunas de las funciones y conceptos que a menudo se combinan con bucles
`for` en Python. La versatilidad del lenguaje permite una variedad de técnicas para procesar
datos de manera eficiente.

Al formatear números con decimales en Python, especialmente utilizando f-strings y el formato

de punto flotante (`:.2f` en tu ejemplo), hay varias opciones adicionales que puedes considerar
para personalizar la presentación de los números. Aquí hay algunas de las opciones comunes:

1. **Número de decimales:**
Puedes ajustar el número de decimales que se muestran. Por ejemplo, si deseas mostrar tres
decimales:

```python
number = 123.4567
print(f"Float: {number:.3f}")
```

Esto imprimirá "Float: 123.457".

2. **Ancho del campo:**

Puedes especificar el ancho total del campo, incluyendo el espacio antes y después del
número. Esto puede ser útil para alinear varios números en columnas. Por ejemplo, si deseas
un campo de ancho 10:

```python
number = 123.4567
print(f"Float: {number:10.2f}")
```

Esto imprimirá "Float: 123.46".

3. **Rellenar con ceros:**

Puedes llenar el espacio antes del número con ceros. Esto es útil para alinear los números en
caso de que tengan diferentes longitudes. Por ejemplo:

```python
number = 7.89
print(f"Float: {number:08.2f}")
```
 Esto imprimirá "Float: 00007.89".

4. **Separadores de miles:**
Puedes agregar separadores de miles para hacer números más legibles. Por ejemplo:

```python
number = 1234567.89
print(f"Float: {number:,.2f}")
```

Esto imprimirá "Float: 1,234,567.89".

Estas son solo algunas opciones básicas, y hay muchas más disponibles. Puedes combinar
estas opciones según tus necesidades específicas para formatear los números de la manera
que mejor se adapte a tu aplicación o presentación de datos. Experimentar con diferentes
combinaciones te permitirá personalizar la salida según tus requisitos.

Ejemplos for:

Funciones ejemplo

suma
def suma_lista(lista):
suma = 0
for elemento in lista:
suma += elemento
return suma

# Ejemplo de uso
mi_lista = [1, 2, 3, 4, 5]
resultado = suma_lista(mi_lista)
print(f"La suma de los elementos de la lista es: {resultado}")
```
Print ASCII

Puedes imprimir el alfabeto ASCII en Python usando la función `chr()` que toma un número
entero y devuelve el carácter ASCII correspondiente. Aquí tienes un ejemplo simple que
imprime el alfabeto en mayúsculas:

```python
for i in range(65, 91): # Rango de valores ASCII para letras mayúsculas
print(chr(i), end=' ')

# Output:
#ABCDEFGHIJKLMNOPQRSTUVWXYZ
```

En este ejemplo, el bucle `for` itera desde el valor ASCII de 'A' (65) hasta el valor ASCII de 'Z'
(90). La función `chr(i)` convierte cada valor a su carácter correspondiente, y `end=' '` se utiliza
para imprimir en la misma línea separando los caracteres por un espacio.

Si deseas imprimir el alfabeto en minúsculas, puedes ajustar el rango del bucle:

```python
for i in range(97, 123): # Rango de valores ASCII para letras minúsculas
print(chr(i), end=' ')

# Output:
#abcdefghijklmnopqrstuvwxyz
```

En este caso, el rango es desde el valor ASCII de 'a' (97) hasta el valor ASCII de 'z' (122).
Esta función llamada `suma_lista` toma una lista como argumento, itera sobre cada elemento
de la lista con un bucle `for` y acumula la suma de esos elementos en la variable `suma`.
Finalmente, devuelve la suma total.

Puedes adaptar y modificar esta función según tus necesidades específicas. El uso de bucles
`for` con listas es muy común en Python y es una forma poderosa de procesar datos de manera
eficiente.

fusionar diccionarios
En Python, hay varias formas de fusionar diccionarios, y la elección de la mejor depende de tus
necesidades y la versión de Python que estés utilizando. Aquí te presento algunas de las
formas más comunes de fusionar diccionarios:
1. **Operador `**` (Python 3.5 y versiones posteriores):**

Puedes utilizar el operador `**` para fusionar dos diccionarios. Este método crea un nuevo
diccionario que contiene las claves y valores de ambos diccionarios. Si hay claves duplicadas,
los valores del segundo diccionario sobrescribirán a los del primero.

```python
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}

merged_dict = {**dict1, **dict2}

print(merged_dict)
```

Salida:
```
{'a': 1, 'b': 3, 'c': 4}

# In Python 2.x you could

# use this:
>>> z = dict(x, **y)
>>> z
{'a': 1, 'c': 4, 'b': 3}

```

2. **Método `update()` (Python 2 y 3):**

El método `update()` se puede utilizar para fusionar un diccionario en otro. Este método
modifica el diccionario actual con las claves y valores del diccionario proporcionado. Si hay
claves duplicadas, los valores del segundo diccionario sobrescribirán a los del primero.

```python
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}

dict1.update(dict2)
print(dict1)
```

Salida:
 ```
{'a': 1, 'b': 3, 'c': 4}
```

3. **Método `|` (Python 3.9 y versiones posteriores):**

En Python 3.9 y versiones posteriores, se introdujo el operador `|` para fusionar diccionarios.

```python
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}

merged_dict = dict1 | dict2

print(merged_dict)
```

Salida:
```
{'a': 1, 'b': 3, 'c': 4}
```

Estas son algunas de las formas comunes de fusionar diccionarios en Python. Elige el método
que mejor se adapte a tus necesidades y la versión de Python que estés utilizando.

ANOTACIONES CON PYTHON

Tipado dinamico de forma implicita, permite flexibilidad cambiando el tipado segun asignación
de variable
Desventaja _ se pueden añadir bugs
Type anotación, lo cual define el tipo de axignacion, se usan : de la siguiente manera

# ANOTACIONES CON PYTHON

# Tipado dinamico de forma implicita, permite flexibilidad cambiando el
tipado segun asignación de variable
# Desventaja _ se pueden añadir bugs
# Type anotación, lo cual define el tipo de axignacion, se usan : de la
siguiente manera

a : int = 10
b : float = 3.14
c : bool = False
d : str = 'Python is great'

# se mejora la claridad y compresion del codigo

username = 'cody'
altura = 1.6
edad = 10
active = True

print(username, altura, edad, active)

# no afecta el interprete
Definir constantes en python

Union
Una variable puede tomar diferentes tipos de datos
Any - optional

Alias