Introducción a Variables de Python

class: center, middle, inverse, title-slide

.title[
# Introducción a Variables de Python
]
.subtitle[
## MAD - UdelaR
]
.author[
### Daniel Miles Touya
]
.date[
### 2025-06-16
]

---

# Introducción a Variables de Python

<b style="color:green">Obtener un resultado una vez ejecutado un script, no significa que el script esté bien</b>

---
# Escribiendo Código en Python

Python es un lenguaje de programación versátil que se puede escribir y ejecutar de múltiples formas, dependiendo de tus necesidades y del entorno en el que trabajes.

<b style="color:green">1.- Editores de texto enriquecidos (IDE o editores de código)</b>

Son programas que permiten escribir código, explorarlo, depurarlo y ejecutarlo fácilmente.

-**Visual Studio Code (VS Code)**: uno de los más populares. Soporta extensiones, resaltado de sintaxis, autocompletado, ejecución integrada y más.

-**PyCharm**: IDE especializado en Python, con herramientas avanzadas para proyectos grandes.

-**Sublime Text**, **Atom**, entre otros.
--
<br>

En estos entornos, puedes:

* Escribir tu código en archivos `.py`, como `hello.py`.

* Ejecutarlos desde la terminal integrada:

```bash
  python hello.py
  ```
---
# Escribiendo Código en Python

<b style="color:green">2.- Terminal interactiva (IPython o Python REPL)</b>

Puedes abrir una terminal y ejecutar:

```bash
python
```

o bien:

```bash
ipython
```

Esto abrirá un entorno donde se puede escribir código línea por línea. Por ejemplo:

```python
>>> print("Hola")
Hola
```

Es ideal para probar fragmentos pequeños de código rápidamente.

---
# Escribiendo Código en Python

<b style="color:green">3.- Entornos interactivos como Jupyter Notebook</b>

Jupyter permite escribir código en bloques o celdas, mezclarlo con texto en Markdown, y ejecutar el código de forma incremental.

* Ideal para análisis de datos, visualizaciones, docencia e investigación.
* Permite ver resultados inmediatamente debajo del código.
* Replicabilidad
* Usa extensiones como `.ipynb` en lugar de `.py`.

---
# Escribiendo Código en Python

En la celda de JN vamos a escribir un _código_ y vamos a guardarlo en un fichero _.py_

.pull-left[
<b style="color:#6082B6">Vamos a escribir</b>
```python
%%writefile hello_JN.py
print("Hola Daniel")
```
]

.pull-right[

<b style="color:#6082B6">Vamos a ver si lo creó</b>
```python
!ls hello_JN.py
```
]

.pull-left[
<b style="color:#6082B6">Vamos a ejecutarlo</b>
```python
%run hello_JN.py
```
]

.pull-right[
<b style="color:#6082B6">Resultado</b>
```python
Hola Daniel
```
]

---
# Escribiendo Código en Python

Cuando escribimos `print("Hola Daniel")` hemos usado una <b style="color:brown">función</b> en Python: una regla o conjunto de instrucciones que, dadas ciertas entradas (o incluso ninguna), realiza una acción y puede producir un resultado.

> En este caso, `print` es una función predefinida que toma un argumento (el texto `"Hola Daniel"`) y produce un efecto: mostrar ese texto en pantalla.

> Veremos que las <b style="color:brown">funciones</b> son una parte fundamental en la escritura de un script en Python.

---
# Escribiendo Código en Python

Un <b style="color:brown">statement</b> (sentencia) es una **instrucción completa que el intérprete puede ejecutar**.

> Es una unidad de código que realiza una acción, y puede o no producir un valor.

Ejemplos de <b style="color:brown">statement</b> comunes

<table class="statements">
  <thead>
    <tr>
      <th>Tipo de statement</th>
      <th>Ejemplo</th>
      <th>Qué hace</th>
    </tr>
  </thead>
  <tbody>
    <tr><td><strong>Asignación</strong></td><td><code>x = 5</code></td><td>Asigna un valor a una variable</td></tr>
    <tr><td><strong>Condicional</strong></td><td><code>if x &gt; 0: ...</code></td><td>Ejecuta código según una condición</td></tr>
    <tr><td><strong>Bucle</strong></td><td><code>for i in range(5): ...</code></td><td>Repite un bloque de código</td></tr>
    <tr><td><strong>Llamada a función</strong></td><td><code>print("Hola")</code></td><td>Ejecuta una función</td></tr>
    <tr><td><strong>Importación</strong></td><td><code>import math</code></td><td>Importa un módulo</td></tr>
    <tr><td><strong>Definición</strong></td><td><code>def mi_funcion():</code></td><td>Define una función</td></tr>
    <tr><td><strong>Clase</strong></td><td><code>class Persona:</code></td><td>Define una clase</td></tr>
    <tr><td><strong>Return</strong></td><td><code>return x</code></td><td>Devuelve un valor</td></tr>
    <tr><td><strong>Pass / Break / Continue</strong></td><td><code>pass</code></td><td>Controla el flujo del programa</td></tr>
  </tbody>
</table>
---
# Esciribendo Código en Python

* Un **statement** no devuelve un valor, a diferencia de una **expresión**. Los **statements** ejecutan acciones.
<br>
<br>
* Las **expresiones** (expressions) se evalúan para producir un valor.
<br>
<br>

```python
x = 2 + 3       # Statement: asignación
2 + 3           # Expression: se evalúa a 5

print(x)        # Statement: llamada a función (produce efecto -side effect)
```

<b style="color:green">Interacción entre ambos</b>

Algunos `statements` **contienen** una o más `expressions`. Por ejemplo:

```python
x = 2 + 3  # ← assignment statement que contiene una expression (2 + 3)
```

---
# Variables

En Python, las <b style="color:brown">variables</b> <em style="color:green">nacen</em> (es decir, se crean o se vinculan por primera vez) cuando se ejecuta un assignment statement.

```python
x = 10
```

> Se evalúa la expresión `10`.

> Se crea el objeto `10` (si no existía ya en memoria).

> El nombre `x` se **vincula** al objeto `10` en el **espacio de nombres (namespace)**.

> Si `x` ya existía, simplemente se **reasigna**.

---
# Variables

<b style="color:tomato">Importante</b>

>Python **no requiere declarar las variables previamente**, como en otros lenguajes (C, Java, etc.).

>Una variable **existe en cuanto se le asigna un valor**.

Ejemplo:

```python
# No existe x aún
x = "hola"     # Aquí nace x
print(x)       # Funciona

x = 42         # x se reasigna (nuevo objeto)
```

---
# Variables

En Python: cualquier <b style="color:brown">objeto</b> se puede asignar a una variable.

>En Python, todo es un objeto!!!!

> Técnicamente: cuando se escribe

````python
x = algo
````
se esta simplemente vinculando el nombre `x` al objeto algo en memoria.

Python no se fija en `types` al momento de la asignación: es un tipado dinámico.

El **tipado dinámico** significa que el tipo de un valor se determina automáticamente en tiempo de ejecución, y una misma variable puede contener objetos de diferentes tipos a lo largo del programa.

````python
x = 5          # x es un int
x = "hola"     # ahora x es un str
x = [1, 2, 3]  # ahora x es una lista
````

---
# Variables

Una `variable` puede ser de cualquier `type`
<style>
---

## Tipos de Objetos en Python

<table class="objetos-python">
  <thead>
    <tr>
      <th>Asignación</th>
      <th>Tipo de objeto</th>
    </tr>
  </thead>
  <tbody>
    <tr><td><code>x = 42</code></td><td><code>int</code></td></tr>
    <tr><td><code>y = 3.14</code></td><td><code>float</code></td></tr>
    <tr><td><code>nombre = "Ana"</code></td><td><code>str</code></td></tr>
    <tr><td><code>activo = True</code></td><td><code>bool</code></td></tr>
    <tr><td><code>nulo = None</code></td><td><code>NoneType</code></td></tr>
    <tr><td><code>lista = [1, 2, 3]</code></td><td><code>list</code></td></tr>
    <tr><td><code>tupla = (4, 5)</code></td><td><code>tuple</code></td></tr>
    <tr><td><code>dic = {"a": 1}</code></td><td><code>dict</code></td></tr>
    <tr><td><code>conjunto = {1, 2, 3}</code></td><td><code>set</code></td></tr>
    <tr><td><code>def saludar(): return "Hola"<br>f = saludar</code></td><td><code>function</code></td></tr>
    <tr><td><code>import math<br>mod = math</code></td><td><code>module</code></td></tr>
    <tr><td><code>class Persona: pass<br>PersonaClase = Persona</code></td><td><code>class</code></td></tr>
    <tr><td><code>persona = Persona()</code></td><td><code>instance</code></td></tr>
  </tbody>
</table>
---
# Variables

En Python:

> Toda **variable** es una referencia a un **objeto** en memoria.

> Cada objeto en Python se caracteriza por tres propiedades fundamentales:

| Propiedad            | ¿Qué representa?                                      | Cómo se obtiene        |
| -------------------- | ----------------------------------------------------- | ---------------------- |
| **Tipo (`type`)**    | La **clase** a la que pertenece el objeto (int, str…) | `type(x)`              |
| **Identidad (`id`)** | La **dirección en memoria** (única) del objeto        | `id(x)` o `hex(id(x))` |
| **Valor**            | El contenido interno del objeto                       | Al evaluar la variable |

---
# Variables

table.objetos-python1 th, 
        table.objetos-python1 td {
            border: 1px solid #dee2e6;
            padding: 5px;
            text-align: left;
            vertical-align: middle;
            word-wrap: break-word;
            line-height: 1;
            overflow: hidden;
            height: 1em;
        }

table.objetos-python1 th {
            background-color: #e9ecef;
            font-weight: 600;
            color: #495057;
            text-align: center;
            font-size: 21px;
            position: sticky;
            top: 0;
            line-height: 1;
            height: 1.1em;
            vertical-align: middle;
        }

table.objetos-python1 code {
            font-family: 'Consolas', 'Monaco', 'Courier New', monospace;
            background-color: #f8f9fa;
            padding: 0px;
            border-radius: 2px;
            font-size: 19px;
            display: inline-block;
            word-break: break-all;
            line-height: 1;
            margin: 0;
        }

/* Colores por columna */
        table.objetos-python1 td:nth-child(1) code {
            background-color: #fff3cd;
            color: #856404;
        }

table.objetos-python1 td:nth-child(2) code {
            background-color: #d1ecf1;
            color: #0c5460;
        }

table.objetos-python1 td:nth-child(3) code {
            background-color: #f8d7da;
            color: #721c24;
        }

table.objetos-python1 td:nth-child(4) code {
            background-color: #d4edda;
            color: #155724;
        }

/* Ancho de columnas optimizado */
        table.objetos-python1 th:nth-child(1),
        table.objetos-python1 td:nth-child(1) { width: 30%; }

table.objetos-python1 th:nth-child(2),
        table.objetos-python1 td:nth-child(2) { width: 20%; }

table.objetos-python1 th:nth-child(3),
        table.objetos-python1 td:nth-child(3) { 
            width: 25%; 
            text-align: center;
        }

table.objetos-python1 th:nth-child(4),
        table.objetos-python1 td:nth-child(4) { width: 25%; }

/* Filas alternas */
        table.objetos-python1 tbody tr:nth-child(even) {
            background-color: #f8f9fa;
        }

/* Hover effect */
        table.objetos-python1 tbody tr:hover {
            background-color: #e3f2fd;
        }

/* Estilo específico para direcciones de memoria */
        .memory-address {
            font-family: 'Courier New', monospace;
            font-size: 17px !important;
            letter-spacing: -0.5px;
            line-height: 1;
        }
    </style>
    
<table class="objetos-python1">
  <thead>
    <tr>
      <th>Asignación</th>
      <th><code>type(objeto)</code></th>
      <th><code>hex(id(objeto))</code></th>
      <th>Valor</th>
    </tr>
  </thead>
  <tbody>
    <tr><td><code>x = 42</code></td><td><code>&lt;class 'int'&gt;</code></td><td><code>0x10fa4b170</code></td><td><code>42</code></td></tr>
    <tr><td><code>nombre = "Ana"</code></td><td><code>&lt;class 'str'&gt;</code></td><td><code>0x10e6b6c30</code></td><td><code>'Ana'</code></td></tr>
    <tr><td><code>lista = [1, 2, 3]</code></td><td><code>&lt;class 'list'&gt;</code></td><td><code>0x11032ff50</code></td><td><code>[1, 2, 3]</code></td></tr>
    <tr><td><code>activo = True</code></td><td><code>&lt;class 'bool'&gt;</code></td><td><code>0x10fa51a30</code></td><td><code>True</code></td></tr>
    <tr><td><code>nulo = None</code></td><td><code>&lt;class 'NoneType'&gt;</code></td><td><code>0x10e2b5f60</code></td><td><code>None</code></td></tr>
    <tr><td><code>dic = {"a": 1}</code></td><td><code>&lt;class 'dict'&gt;</code></td><td><code>0x11022c3d0</code></td><td><code>{'a': 1}</code></td></tr>
    <tr><td><code>def saludar(): return "Hola"<br>f = saludar</code></td><td><code>&lt;class 'function'&gt;</code></td><td><code>0x10ebd8e50</code></td><td><code>&lt;function saludar&gt;</code></td></tr>
    <tr><td><code>import math<br>mod = math</code></td><td><code>&lt;class 'module'&gt;</code></td><td><code>0x10fbd18f0</code></td><td><code>&lt;module 'math'&gt;</code></td></tr>
    <tr><td><code>class Persona: pass<br>PersonaClase = Persona</code></td><td><code>&lt;class 'type'&gt;</code></td><td><code>0x1102563a0</code></td><td><code>&lt;class '__main__.Persona'&gt;</code></td></tr>
    <tr><td><code>persona = Persona()</code></td><td><code>&lt;class '__main__.Persona'&gt;</code></td><td><code>0x110274f40</code></td><td><code>&lt;__main__.Persona object&gt;</code></td></tr>
  </tbody>
</table>

> Los valores de `id` y `hex(id(...))` cambian en cada ejecución (identifican el lugar en memoria).

---
# Variables

<b style="color:brown"> ¿Cómo se **evalúa** una asignación?</b>

>>La evaluación ocurre en dos pasos:

>>1. **Evaluar la expresión del lado derecho** (RHS)

>>2. **Asignar el resultado al nombre del lado izquierdo** (LHS)

```python
x = 2 + 3
````

1️⃣ Se evalúa `2 + 3` → da `5`.

2️⃣ Luego se asigna ese valor a `x`.

Python no "copia" el valor `5`: `x` simplemente **apunta** al objeto `5` en memoria.

.pull-left[
```python
print(id(x))     
print(type(x))   
print(x)        
```
]

.pull-right[
```python
>>> 4383041872
>>> <class 'int'>
>>> 5
```
]

---
# Variables

<b style="color:brown" > Evaluación del statement de asignación</b>

¿Es válida la expresión?

```python
  i = i + 1
 ```
--

.pull-left[
Es decir, si ejecutamos
````python
i = 5
i = i + 1
````
]

.pull-left[
Tendremos como resultado

a.- `6` <br>
b.- `5` <br>
c.- `Syntax error`

]

**Recordar**: primero se evalua el lado derecho, luego se asigna el resultado al lado izquierdo de la asignación `=`

1️⃣ Se evalua `5 + 1 `  → da ` 6`.

2️⃣ Luego se asigna ese valor a `i`.

---
# Variables: `type`

Es importante  conocer el **`type` de un objeto **

>El `type` determina el comportamiento de un objeto

>>Cada tipo de objeto define:

>>* Qué **operaciones** puedes realizar (`+`, `in`, `len()`…)

>>* Qué **métodos** están disponibles (`append`, `split`, etc.)

>>* Cómo se comporta al interactuar con otros objetos

```python
x = "5"
y = 2
print(x + y)  # ❌ Error: no se puede sumar str e int
```

---
# Variables: `type`

>**Evitar errores**

>> Muchos errores en tiempo de ejecución vienen de no conocer el tipo:

```python
edad = input("Edad: ")  # tipo str
doble = edad * 2        # repite la cadena, no la multiplica
```

```python
# Solución
edad = int(edad)
doble = edad * 2
```
--

>Permite **adaptar tu código**

Conocer el tipo te permite escribir código seguro y flexible:

```python
if isinstance(x, list):
    x.append(10)
```

---
# Variables: type `str`

- Un `str` (string) es una **secuencia inmutable de caracteres**.

- Se puede definir con comillas **simples** (`'texto'`) o **dobles** (`"texto"`).

- Python **no diferencia** entre `'Hola'` y `"Hola"`.

>Definir un string (`str`) en Python

.pull-left[
Formas válidas

```python
a = "Hola"
b = 'Mundo'
c = "123"
d = ''  # Cadena vacía
e = "Hola 'mundo'"
f = 'Ella dijo "sí"'
```
]

.pull-right[
No puedes mezclar `'` y `"` sin escapar o cerrar correctamente.

```python
mensaje = "Hola 'mundo'"     # ✅ válido
mensaje = 'Hola "mundo"'     # ✅ válido
mensaje = "Hola "mundo""     # ❌ error de sintaxis
```
]

---
# Variables: type `str`

.pull-left[
**Concatenación**
```python
nombre = "Ana"
saludo = "Hola, " + nombre + "!"
# 'Hola, Ana!'
```
]

.pull-right[
**Añadir espacios**
```python
a = "uno"
b = "dos"
a + " " + b
# 'uno dos'
```
]

.pull-left[
**Repetición**
```python
"ha" * 3
# 'hahaha'
"-" * 10
# '----------'
```
]

.pull-right[
**Métodos asociados a `str`**
```python
dir(str)
```
]

---
# Variables: type `str`

.pull-left[
**Conversión**
```python
s = "python"
s.upper()        # 'PYTHON'
help(str.upper)
s.lower()        # 'python'
s.capitalize()   # 'Python'
```
]

.pull-right[
**Limpiar Espacios**
```python
"  hola  ".strip()   # 'hola'
"---".strip("-")     # ''
# Longitud
len("hola")
```
]

--
.pull-left[
**Buscar y remplazar**
```python
"banana".replace("a", "o")
# 'bonono'
"data.csv".endswith(".csv")
# True
"python".startswith("py")
#True
```
]

.pull-right[
**`str`: Sequencia**
```python
s = "python"
s[0]    # 'p'
s[2]    # 't'
s[-1]   # 'n'
s[-2]   # 'o'
s[1:4]      # 'yth'
s[:3]       # 'pyt'
s[::2]      # 'pto'
```
]

---
# Variables: type `str`

<b style="color:green">Ejercicio de Comprensión</b>
<b style="color:brown">El cifrado de César</b>

El cifrado César es una de las técnicas más antiguas de **criptografía.**

Su nombre viene de Julio César, quien lo usaba para proteger mensajes militares.

>Es un **método de sustitución** muy simple:

>> Cada letra del mensaje original se reemplaza por otra letra que está un **número fijo de posiciones más adelante** en el alfabeto.

---
# Variables: type `str`

<b style="color:green">Ejercicio de Comprensión</b>
<b style="color:brown">El cifrado de César</b>

Por ejemplo, con **desplazamiento 3**:

| Letra original | Nueva letra             |
| -------------- | ----------------------- |
| A              | D                       |
| B              | E                       |
| C              | F                       |
| ...            | ...                     |
| Z              | C (vuelve al principio) |

Para **recuperar el mensaje original**, hacemos el proceso inverso:

* Reemplazamos cada letra por otra que está **3 letras antes** en el alfabeto.

---
# Variables: type `str`

<b style="color:green">Ejercicio de Comprensión</b>
<b style="color:brown">El cifrado de César</b>

Ejemplo

Supongamos que el mensaje cifrado es:

```
"frq"   ← mensaje cifrado
```

Queremos recuperar el mensaje original, usando desplazamiento 3:

* `'f' → 'c'`
* `'r' → 'o'`
* `'q' → 'n'`

Entonces, el mensaje original es:

```
"con"
```
---
# Variables: type `str`

<b style="color:green">Ejercicio de Comprensión</b>
<b style="color:brown">El cifrado de César</b>

````python
# Codificador para 3 letras
abc = "abcdefghijklmnopqrstuvwxyz"
mensaje = "con"  # mensaje a cifrar
desp = 3         # desplazamiento

# letra 1
letra1 = mensaje[0]
pos1 = abc.find(letra1)
nueva1 = abc[(pos1 + desp) % 26]
# letra 2
letra2 = mensaje[1]
pos2 = abc.find(letra2)
nueva2 = abc[(pos2 + desp) % 26]
# letra 3
letra3 = mensaje[2]
pos3 = abc.find(letra3)
nueva3 = abc[(pos3 + desp) % 26]
# mensaje cifrado
cifrado = nueva1 + nueva2 + nueva3
print(cifrado)  # Resultado: 'frq'
````

---
# Variables: type `str`

<b style="color:green">Ejercicio de Comprensión</b>
<b style="color:brown">El cifrado de César</b>

````python
# DeCodificador para 3 letras
abc = "abcdefghijklmnopqrstuvwxyz"
mensaje = "frq"   # Parte inicial de "frqwudgr..."

# letra 1: 'f'
letra1 = mensaje[0]
pos1 = abc.find(letra1)      # índice de 'f' = 5
nueva1 = abc[(pos1 - 3) % 26]  # 5 - 3 = 2 → 'c'
# letra 2: 'r'
letra2 = mensaje[1]
pos2 = abc.find(letra2)      # índice de 'r' = 17
nueva2 = abc[(pos2 - 3) % 26]  # 17 - 3 = 14 → 'o'
# letra 3: 'q'
letra3 = mensaje[2]
pos3 = abc.find(letra3)
nueva3 = abc[(pos3 - 3) % 26]

# juntar resultado
descifrado = nueva1 + nueva2 + nueva3
print(descifrado)  # 'con'
````
---
# Variables: type `str`

<b style="color:green">Ejercicio de Comprensión</b>
<b style="color:brown">El cifrado de César</b>

Escribir el codigo anterior para una palabra de 4 letras:

Por ejemplo: `hola`

Y escribirlo de manera tal que el desplazamiento sea una variable a la que se le asigne el número de letras a desplazar.

<button onclick="pedirPassword()" style="color:brown">Ver solución</button>

<a href="Solucion_cesar.html" target = "_blank">Cesar</a>
--

Mas adelante vamos a ver cómo, con funciones, condicionales y bucles podemos generalizar este script.

---

# Variable type `int`

.pull-left[
<b style="color:#6082B6">Pidamos al usuario dos enteros</b>
```python
x = input("¿Cuál es x? ")
y = input("¿Cuál es y? ")
print(x + y)
```
]

.pull-right[
<b style="color:#6082B6">¿Que `type` es `x` o `y`?</b>
```python
x = input("¿Cuál es x? ")
print(type(x))
y = input("¿Cuál es y? ")
print(type(y))
```
]

.pull-left[
<b style="color:#6082B6">Convertir el `type` a `int`</b>
```python
x = int(input("¿Cuál es x? "))
print(type(x))
y = int(input("¿Cuál es y? "))
print(type(y))
print(x+y)
```
]

.pull-right[
Objetos: segun su `type`tienen asociado

**Atributos** → Son variables internas del objeto que describen su estado o propiedades.

**Métodos** → Son funciones asociadas al objeto que permiten modificarlo o interactuar con él.
]

---
# Variables type `float`

.pull-left[
<b style="color:#6082B6">Convertir el `type` a `float`</b>
```python
x = float(input("¿Cuál es x? "))
y = float(input("¿Cuál es y? "))
print(round(x / y, 2))  
print(f"{x / y:.2f}") 
```
]

--
.pull-righ[
<b style="color:#6082B6">¿Qué es un `f-string`?</b>
]

.pull-left[
<b style="color:#6082B6">Veamos: que es `round` o `.2f`</b>

Cuando no sabemos algo: <b style="color:tomato">preguntamos</b>

> <a href= "https://docs.python.org/3/library/functions.html" style="color:brown">**Built in Functions**: Documentation</a>

]

---
# Variables

<b style="color:brown">Importante:</b> Una **variable** en Python no es ni exactamente un  <b style="color:#6082B6">contenedor</b> (como en C), ni exactamente un  <b style="color:#6082B6">puntero</b> (como en C++). 
 
> Una variable es mejor entenderla como un nombre que referencia un objeto en memoria.

>> El nombre de la variable se vincula (apunta) a ese objeto

>> No guarda el valor internamente, sino que lo apunta de forma indirecta (_pointers ocultos_).

---
# Variables

<b style="color:green">Ejercicio</b>

> Profundizar en la comprensión de una variable.

>> <a href="https://www.youtube.com/watch?v=Bz3ir-vKqkk">Ver este video</a>

> Realizar ejercicios en

>> <a href="python_ejercicios_variables.html" target = "_blank" style="color:green">Ejercicio Variables</a>

>> <a href="python_ejercicios_strings.html" target = "_blank" style="color:green">Ejercicio Strings</a>