## Variables 1.

0
Las variables son datos que pueden variar sus valores, a los cuales se les da un
nombre o etiqueta con el fin de identificarlos y operar mas fácilmente con ellos.
EJ: Nombre, Edad, Contraseña, etc.
``` Python
Nombre = "Jane"
Apellido = "White"
Edad = 22
Contraseña = "Patatax22"
Resultado prueba de embarazo = False
```

Las variables se componen de 2 partes, la declaración que es su nombre o etiqueta,

y la definición que es el dato que contiene esa variable. Ambas partes están
separadas por un signo = en el medio que las diferencia, tal como se muestra en el
siguiente ejemplo.

``` Python
Declaracion = Definicion
```

Al ser variables valga la redundancia, su valor puede cambiar a medida que se leen
las líneas de código, tal como se muestra a continuacion:
``` Python
Nombre = 'Juan'
Nombre = 'Martinez'
Nombre = 'Julieta'

print (Nombre)
```
Como el código se lee de forma secuencial, ósea linea por linea, eso quiere decir
que el valor de la variable será igual al ultimo valor establecido, por lo tanto al
ejecutarlo el nombre que se imprimirá será Julieta en este caso.

### Variación de valores numéricos

Para variar valores numéricos se puede modificar como se le hace a un String, o
operar aritméticamente con ellos.

Ej:
``` Python
numero = 10
numero = 10 + 5

print (numero)
```
Resultado = 15

Aunque para evitar ser tan engorroso se puede escribir también de la siguiente
manera, manteniendo así el mismo resultado:
``` Python
numero = 10
numero += 5

print (numero)
```

Existen varios operadores aritméticos que se irán recopilando en la siguiente

lista:
- Suma **( + )**
- Resta **( - )**
- Multiplicación **( * )**
- Potenciación **( ** )**
- División **( / )**
- División con resultado entero **( // )**
- Resto de la división **( % )**

### Concatenación de Strings (Unir cadenas de texto)

Concatenar significa unir cadenas, ósea que esta función une cadenas de texto.

#### Concatenación básica texto-texto:

Para unir cadenas de texto se pone el operador +, con el fin de dar a entender que
se desea unir con que:
``` Python
nombre = "Carlos"
Bienvenida = "Hola" + nombre + "¿Como estas?"

print (Bienvenida)
```
Resultado = HolaCarlos¿Como estas?

Pero ocurre un problema, porque es que se escribe todo junto? Donde estan los
espacios?
Bueno pues esto se debe a que al concatenar se toman todos los caracteres del
String incluidos los espacios y se unen en una unica cadena de texto, debido a lo
cual si no hay espacios en los Strings a juntar se fusionara todo en una unica
palabra. Lo cual quiere decir que solucionar el problema es tan fácil como agregar
espacios en los puntos a unir.

**Solucion:**
``` Python
nombre = "Carlos"
Bienvenida = "Hola " + nombre + " ¿Como estas?"

print (Bienvenida)
```
**Resultado** = Hola Carlos ¿Como estas?

#### Concatenación fString texto-numero:

Todo bien con la forma anterior, pero ocurre un problema, no sirve para números, si
se intenta unir un String con un int o float con el método anterior dará error.

Ej:
``` Python
numero = 5
Bienvenida = "Hola " + numero + " ¿Como estas?"

print (Bienvenida)
```
**Resultado** = Error

Como arreglamos esto? Es sencillo, solo debemos a pasar a usar fStrings, que tienen
la siguiente estructura:
Se agrega una **f** al inicio de las **""** del String y para insertar la
**variable** ya no se usa el operador +, sino que se pone la variable a agregar
entre **{ }** directamente en el punto de la cadena deseado.
Ej:
``` Python
numero = 5
Bienvenida = f"Hola {numero} ¿Como estas?"

print (Bienvenida)
```
Resultado = Hola 5 ¿Como estas?

De esta forma podemos usar todos los tipos de datos y no solo Strings para una
cadena de texto. Esto ocurre debido a que la función u operador fString
transformara todo lo que este entre "" en un String, que será el valor de la
variable declarada.

### Borrar variables:

Para borrar una variable se usa el comando **del** seguido de la Variable a
eliminar.

Ej:
``` Python
numero = 5
Bienvenida = f"Hola {numero} ¿Como estas?"
del Bienvenida
print (Bienvenida)
```
Resultado = Error

Ej2:
``` Python
numero = 5
Bienvenida = f"Hola {numero} ¿Como estas?"
del numero

print (Bienvenida)
```
Resultado = Hola 5 ¿Como estas?

Pero aquí ocurre un problema, porque el primer ejemplo funciona y el segundo no?
Bueno pues no es que no haya funcionado el **del** en el Ej2, sino que lo que
ocurre es que por producto de la secuencialidad del código la Variable numero se
borro después de que esta modificara la variable Bienvenida, lo cual no interfirió
en la ejecución del código, permitiendo que salga el resultado.
Ahora si cambiamos el orden del codigo ahi si llegariamos al error.

Ej3:
``` Python
numero = 5
del numero
Bienvenida = f"Hola {numero} ¿Como estas?"

print (Bienvenida)
```
Resultado = Error

### Operadores de pertenencia:

Devuelven un resultado **Booleano** que puede ser True o False dependiendo de si el
valor especificado esta dentro de la variable a comparar.

`in` devuelve True si el valor especificado se encuentra en la secuencia. En caso

contrario devuelve False.

`not in` devuelve True si el valor especificado no se encuentra en la secuencia. En

caso contrario devuelve False.

Ejemplos:
```Python
a = [1,2,3,4,5]

#Esta 3 en la lista a?
print (3 in a) # Muestra True

#No está 12 en la lista a?

print (12 not in a) # Muestra True

str = "Hello World"

#Contiene World el string str?

print ("World" in str) # Muestra True

#Contiene world el string str? (nota: distingue mayúsculas y minúsculas)

print ("world" in str) # Muestra False

print ("code" not in str) # Muestra True

```

**Precaucion!!!!:** ==Tener cuidado con las mayúsculas y minúsculas, por un solo

carácter de diferencia al consultar puede cambiar totalmente el resultado.==

### Comentarios:
Para comentar el código en Python es tan fácil como poner un # al inicio de la
parte de la linea de código que se quiere comentar. Esto lo que hace básicamente es
decirle al interprete de Python que a partir del # hasta la siguiente linea de
código no se ejecutara lo que haya escrito en esa zona, lo cual quiere decir que es
una parte en la que se puede escribir lo que sea sin afectar el programa.

Ej:
``` Python
# Definiendo una variable
nombre = "Lucas"

# Concatenar con +
bienvenida = "Hola " + "Como estas?"

# Concatenar con f-Strings

bienvenida = f"Hola {nombre} Como estas?"

# Operadores de pertenencia ( in / not in )

print ("Lucas" in bienvenida) #True
print ("Lucas" not in bienvenida) #False
```

### Nombrar variables con nombres de mas de 1 palabra

Para esto existen varias formas, entre ellas camelCase y snake_case, de las cuales
la segunda es la usada por desarrolladores profesionales para aumentar la
legibilidad del codigo.

La diferencia consiste en que camleCase usa mayusculas al inicio de las palabras

para separarlas, mientras que snake_case usa el " _ ", lo cual vuelve el codigo
mucho mas legible.

Ej:
``` Python
# Ej camelCase
nombreCompletoDeTuTioMaster = "Lucas"

# Ej snake_case
nombre_completo_de_tu_tio_master = "Lucas"
```

---
## Variables 2.0

### Desempaquetado
El desempaquetado es una forma de crear variables nuevas, tomando como valor los
valores de listas o tuplas.

Ej:
```Python
# ========================= ( Forma correcta: ) =========================

datos = ('Lucas','Dalto',1000000)
# Creamos una tupla

nombre,apellido,subs = datos
# Se declaran los nombres de las variables a crear y se separan por comas, y esto
se iguala a datos.
# Lo que hara esto es en orden ir leyendo los elementos de la lista o tupla y
asignandolos como valor a nuevas variables creadas automaticamente con los nombres
dados anteriormente.
# Si el numero de elementos de la tupla/lista no coincide con el numero de
variables a crear el codigo dara una excepción/ERROR.

print(nombre) # Rta = 'Lucas'

print(subs) # Rta = 1000000
print(apellido) # Rta = 'Dalto'

# ======================== ( Forma incorrecta: ) =========================

# [ Caso 1: ]

datos = ('Lucas','Dalto',1000000)

nombre,apellido = datos # Dara ERROR!!!

# [ Caso 2: ]

datos = ('Lucas','Dalto')

nombre,apellido,subs = datos # Dara ERROR!!!

```

### Otros métodos para crear tuplas

Existen un par de formas extra para crear tuplas

```Python
# Creando tupla con tuple() (Como parametro hay que darle una lista)
tupla = tuple(['dato1','dato2'])

# Creando una tupla sin parentesis de multiples datos

tupla = "dato1","dato2"

# Creando una tupla sin parentesis de un solo dato

tupla = "dato",

print(type(tupla)) # Rta = class 'tuple'

```

#### Porque las tuplas son inmutables?

Esto ocurre debido a que a diferencia de las listas que poseen 2 direcciones de
memoria asignada, las tuplas solo poseen 1, lo cual hace que debido a la falta de
redundancia de datos en memoria, estas tengan una gran posibilidad de borrarse en
caso de un error de escritura en los datos, razón por la cual se declaran como
inmutables en la sintaxis del lenguaje de programación, con el fin de evitar esto.
Las tuplas son útiles en los casos en los que es necesario trabajar con constantes.

### Otros métodos para crear conjuntos

Los conjuntos pueden ser creados también con la función set(), a la cual se le pasa
como entrada un iterable.

```Python
# Creando un counjunto con set()
conjunto = set(["Pepe","Hector","juan",1000])

# [ Insertando datos externos en el conjunto: ]

# Para insertar datos de otro array en un conjunto se debe introducir un array que
sea inmutable, osea una tupla, ya que en caso de hacerlo con una lista el codigo
dara ERROR.

# [ Ej con lista: ]
conjunto = set(["Dato 1",["Dato en lista-1","Dato en lista-2"]])
# Rta = ERROR

# [ Ej con tupla: ]
conjunto = set(["Dato 1",("Dato en lista-1","Dato en lista-2")])
# Rta = {"Dato 1","Dato en lista-1","Dato en lista-2"}

# ============== [ Insertar un conjunto dentro de otro conjunto: ] ==============

# [ Forma incorrecta: ]
conjunto1 = {"Dato1","Dato2"}
conjunto2 = {conjunto1,"Dato3"}
# Rta = ERROR

# [ Forma correcta: ]
# Se debe usar la funcion frozenset para volver al conjunto a insertar inmutable.
conjunto1 = frozenset(["Dato1","Dato2"])
conjunto2 = {conjunto1,"Dato3"}
# Rta = {"Dato3",frozenset({"Dato1","Dato2"})}
```

### Teoría de conjuntos

En teoría de conjuntos tenemos 2 tipos de conjuntos, los sub-conjuntos y los super-
conjuntos, dependiendo de que se tome de referencia. Los sub-conjuntos son
conjuntos que están dentro de otro conjunto mas grande que los contiene. Un
conjunto que contiene varios subconjuntos de denomina super-conjunto.

Ej:
```Python
a = {1, 2, 10} # Sub-conjunto
b = {25, 31} # Sub-conjunto

c = {1, 2, 10, 25, 31} # Super-conjunto

# En este ejemplo a y b son sub-conjuntos de c, ya que son contenidos por este,

mientras que c es el super-conjunto de a y b, ya que es el que contiene a estos 2.
```

#### Verificando si es un sub-conjunto, un super-conjunto y si los conjuntos son

totalmente distintos (Respuesta booleana):
```Python
conjunto1 = {1, 2, 10}
conjunto2 = {1, 2, 10, 25, 31}

# Verificando si es un sub-conjunto de otro conjunto

resultado = conjunto1.issubset(conjunto2) # Rta = True
resultado = conjunto1 <= conjunto2 # Rta = True
# Ambas maneras son validas

# Verificando si es un super-conjunto de otro conjunto

resultado = conjunto1.issuperset(conjunto2) # Rta = False
resultado = conjunto1 > conjunto2 # Rta = False
# Ambas maneras son validas

# Verificando si hay un numero en comun

resultado = conjunto1.isdisjoint(conjunto2) # Rta = False
# Si entre ambos conjuntos todos los valores son distintos dara True, si aunque sea
uno de estos valores coincide automaticamente los conjuntos seran iguales, por lo
que dara False.
```

### Diccionarios 2.0

```Python
# Creando diccionarios con dict()
diccionario = dict(nombre="Lucas",apellido="Dalto")
# Es necesario pasarle de argumento las claves y valores, separados por comas para
crearlos.
# Con dict() se pueden crear diccionarios vacios.

# Las tuplas pueden ser claves (Las listas y conjuntos no, a exceocion de conjuntos
frozenset).
diccionario = {("dalto","rancio"):"jajas"} # Forma correcta

diccionario = {["dalto","rancio"]:"jajas"} # Forma incorrecta1

diccionario = {{"dalto","rancio"}:"jajas"} # Forma incorrecta1

# Creando diccionarios con fromkeys() (Crea diccionarios vacios, sin valores)

diccionario = dict.fromkeys("nombre","apellido")
# Rta = {'n': 'apellido', 'o': 'apellido', 'm': 'apellido', 'b': 'apellido', 'r':
'apellido', 'e': 'apellido'}
# Eh? Que paso aca? Lo que ocurrio es que al no pasarle una lista de parametro, lo
que hara fromkeys() es agarrar la primera palabra de clave y separarla en letras.
Luego las letras pasaran a ser los nombres de las claves, mientras que la segunda
palabra sera el valor que tomaran todas las claves.

# Para evitar esto se le debe pasar una lista de parametro (valor por defecto:
none)
diccionario = dict.fromkeys(["nombre","apellido"])
# Rta = 'nombre': 'none', 'apellido': 'none'

# Creando diccionarios con fromkeys(), cambiando el valor por defecto.

diccionario = dict.fromkeys(["nombre","apellido"],"No se")
```

---

Nexo: [[200_-_Memoria_Digital/Programacion/Cursos/Nexo cursos de programacion de

dalto|Nexo cursos de programacion de dalto]]

Anterior: [[200_-_Memoria_Digital/Programacion/Cursos/Python/Datos|Datos]]

Siguiente: [[200_-_Memoria_Digital/Programacion/Cursos/Python/Operadores|
Operadores]]

#programacion #Python