# ---
# jupyter:
#   jupytext:
#     text_representation:
#       extension: .py
#       format_name: light
#       format_version: '1.5'
#       jupytext_version: 1.14.4
#   kernelspec:
#     display_name: Python 3
#     language: python
#     name: python3
# ---

# + [markdown] colab_type="text" id="w4qMIrSBipQC"
# # Tipos de Datos Básicos

# + [markdown] colab_type="text" id="b79w139Ji0Me"
# ## Números
#
# - **Enteros**: `20`, `12`, `-5`, `0`, `10920398983497549`
# - **Coma Flotante**: `3.5`, `-0.7`, `9837948.3284738`, `-19232343.845798`
# - **Complejos**: `2+3j`, `-1+8j`, `-67j`
#
# Pueden ser de cualquier tamaño, no hay límite. Tanto positivos como negativos. E inclusive podemos utilizar **Notación científica**: `2e3`, `10e-8`, `1.23e-5`.
#
# Recordemos que la coma decimal se escribe con `.`. Y podemos utilizar el símbolo `_` como separador de miles. Por ejemplo, podemos guardar el valor 123.000 en la variable x con la sentencia:
#
# - `x = 123000`
#
# o con la sentencia:
#
# - `x = 123_000`

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="spR8wfRxiHSD" outputId="e043b3a0-aee0-4664-ef0e-32508241b8af"
20

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="8nVsc2p1kDIh" outputId="de82fd18-dfc8-4750-872f-0221a55512f9"
9837948.3284738

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="KSc1haJfkSjZ" outputId="004e67cf-27b0-4ad4-d8d6-dbaf409b4fca"
-67j

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="O1j_wG9RkWdP" outputId="f55e2e8e-bc43-48e4-8b87-050584996e0e"
2e3

# + [markdown] colab_type="text" id="MgLCrX3wkaAq"
# Podemos usar la función `type()` para que nos diga qué tipo de dato es el que estamos usando. Según el tipo de dato que tengamos la función nos dirá:
# - `int` para los números enteros (del inglés "integer")
# - `float` para los números en coma flotante (del inglés "floating point")
# - `complex` para los números complejos

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="O-Pa-ZwqkjUp" outputId="a5248c0b-7b57-48e6-c66c-33dd96f616bb"
type(20)

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="bLSZ0a-0khIm" outputId="50b3991c-00f5-43cb-f934-48a0076ed7f5"
type(9837948.3284738)

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="yn8gM43Bkr3i" outputId="cff01b31-64b6-4d31-c612-0d7e29ee2a2f"
type(-67j)

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="O4tEZwiplKyQ" outputId="5bae9855-094b-4c90-e466-7a54571f2e12"
type(2e3)

# + [markdown] colab_type="text" id="BrkxgpTGlrPI"
# Jugá un poco con los números y la función `type()`. Definí una variable `numero` y cambiale su valor para representar diferentes tipos. Usá `type(numero)` para ver si obtenés los tipos de números que estás queriendo:

# + colab={} colab_type="code" id="oiRSq5uSlxT_"


# + [markdown] colab_type="text" id="BJ8fQ5sFnrei"
# ## Operadores aritméticos
#
# - Suma: `+`
# - Resta: `-`
# - Multiplicación: `*`
# - División: `/`
# - Módulo: `%`
# - División Entera: `//`
# - Potenciación: `**`

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="KOrhYULIoOyj" outputId="d70dffc4-b8d0-4e94-c065-18978f5be0ed"
a = 5
a + 2

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="8Aai_shYoiRV" outputId="147f6bcc-cba9-4847-e3e3-07b1f039719c"
a * 2

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="mb_zD6nColGt" outputId="2a5941ce-2e45-44ad-b550-a6c209d0cb05"
a ** 2

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="Azxzazr4ooVx" outputId="4c5862ec-6e6b-4bf7-8356-ab344948daf2"
4.5 * 8

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="SGy7RTORotcc" outputId="36f83267-787b-484a-9755-9cdb5f42a2ba"
10 / 3

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="moOggXu6oxFZ" outputId="dd858eb2-17c7-496e-f31c-2574925bc1e7"
10 % 3

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="_jTpUOAMowWU" outputId="af16756c-943d-4ce7-8511-c1ba8c8b16c0"
10 // 3

# + [markdown] colab_type="text" id="QQQEVWohpLpG"
# ### Precedencia de los operadores
#
# Los operadores aritméticos respetan la regla PEMDAS de precedencia. Es decir, se resuelven con el siguiente orden:
#
# 1. **P**aréntesis
# 2. **E**xponciación (potencia)
# 3. **M**ultiplicación (producto)
# 4. **D**ivisión (cociente)
# 5. **A**dición (suma)
# 6. **S**ubstracción (resta)
#
# Muchos terminamos usando Python como nuestra calculadora personal, te animás?

# + colab={} colab_type="code" id="Lc7itMicpR4c"


# + [markdown] colab_type="text" id="amtT-wZ1l3_h"
# ## Cadenas de Texto
#
# Las cadenas de texto en Python se definen entre comillas dobles `"` o comillas simples `'`. Por eso en la función `print()` pusimos como argumento `"Hola mundo!"`, también es válido poner `'Hola mundo!'`.

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="hcETRNtlmhJo" outputId="067ae633-b875-4aa6-ab59-5b5cc3227b53"
print('Hola mundo')

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="5qPiAg8Up2eC" outputId="14f7ad7e-b202-4080-ea75-cbb36d075aa2"
type("Hola mundo!")

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="9sShxxQwp5-d" outputId="d63707f6-32ae-458e-bab4-3f46b23877f6"
type('Hola mundo')

# + [markdown] colab_type="text" id="m6qAiVrbmjQn"
# Si a `type` le pasamos una cadena de texto nos devuelve `str` (del inglés, *String*).
#
# Si queremos poner cadenas de texto multilínea, podemos utilizar triple comilla simple `'''` o triple comilla doble `""""`.
# Lo que no podemos hacer es mezclar las comillas que usamos. Si empezamos con `"`, terminamos con `"`. Lo mismo para `'`.

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="sSFIT8zknfPO" outputId="b9e6f25d-fe05-4ccd-83c2-4b7df70a6719"
parrafo = """En un lugar de la Mancha, de cuyo nombre...
Es, pues, de saber que este sobredicho hidalgo, los ratos...


Con estas razones perdía el pobre caballero el juicio, y...
"""
parrafo.istitle()

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="eshm_bqmTDCa" outputId="9890df4a-e56c-4e85-e77a-4994c94b8273"
titulo = "Don Quijote"
titulo.istitle()

# + [markdown] colab_type="text" id="Ee7QL1_hnjs1"
# Ahora es tu turno...
#

# + colab={} colab_type="code" id="0jFNJ0R5nigi"


# + [markdown] colab_type="text" id="UXnTS-L8pvan"
# Otra de las funciones que viene con Python, además de `print` y `type` que ya las hemos visto, es la función `len` que devuelve la longitud del objeto que le pasemos como argumento. En el caso de las cadenas de texto nos devolverá la longitud de la cadena, es decir, la cantidad de caracteres de la misma.
#         

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="iDBfmNNtu_XU" outputId="d0f4ccc0-08de-4465-dc0d-3819fbbe83f9"
len(titulo)

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="XafXDoQkvD7l" outputId="be5223f4-9516-44ec-ec85-a2ab4cc15f81"
len(parrafo)

# + [markdown] colab_type="text" id="_WV1cf5VvJH2"
# Escribí tu nombre en una variable y hacé que Python calcule la longitud del mismo:

# + colab={} colab_type="code" id="L5m_ClHCvPcV"


# + [markdown] colab_type="text" id="Ok1iTFllpxtD"
# ### Métodos en cadenas
#
# Las cadenas de texto admiten varios métodos que se pueden llamar con un punto a continuación de la cadena. Por ejemplo: el método `upper()` devuelve en mayúsculas el texto.

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="3F1-SN6sqgVP" outputId="6371c815-381b-4a18-afb0-bdc074f3e337"
"En un lugar de la Mancha, de cuyo nombre...".upper()

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="vmMJSvHSqsMj" outputId="c719d708-26ed-469f-b126-e2bec5eb42ec"
x = "En un lugar de la Mancha, de cuyo nombre..."
x.upper()

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="iqDG0MxKRq7S" outputId="97ba1ed5-ce5c-4500-fbad-3223489a7ba7"
x.isdigit()

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="3QUVIaNMRv0Y" outputId="1bb89755-750a-4539-e56e-eec339c39544"
x.split(',')

# + [markdown] colab_type="text" id="x_wnNkl1qyJ6"
# Ya sea que lo ejecutemos sobre la misma cadena o si la tenemos guardada en una variable, los métodos de cadenas se pueden ejecutar indistintamente.
#
# Si queremos ver qué métodos tenemos disponibles, podemos usar la funcón `dir` sobre una cadena.

# + colab={"base_uri": "https://localhost:8080/", "height": 1000} colab_type="code" id="H_njc_XlrH51" outputId="685714e7-9675-423f-8fef-27edfb6ae5c7"
dir(x)

# + [markdown] colab_type="text" id="gD5U8hRwrNDr"
# Intentá descifrar qué hace cada método sobre la cadena que tenemos almacenada en `x`:

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="l3Y9BteDrVXw" outputId="b5d3eddc-aa33-4be1-f00d-68e90f7844f2"
x.lower()

# + [markdown] colab_type="text" id="m2J1Jwp6JvtB"
# Para no andar jugando a los detectives Python nos ofrece además la función `help` que nos informa con una breve ayuda sobre el método que queremos saber:
#
# > Fijate que luego de `lower` no ponemos los `()`. Ya que si ponemos los paréntesis Python primero ejecutará el método `lower()` sobre la variable `x` y eso es un `str`.

# + colab={"base_uri": "https://localhost:8080/", "height": 139} colab_type="code" id="vWrAybkYJvO2" outputId="e8b884c2-1ca4-4588-cdec-b5e31af361c1"
help(x.lower)

# + [markdown] colab_type="text" id="VfP8WtChpXOW"
# ### Formateando cadenas de texto
#
# Si bien hay varias formas de darle formato a las cadenas de texto, lo más práctico es usar las `f-string`. Anteponemos una letra `f` al comienzo de la cadena y luego dentro de la misma utilizamos las `{}` para poner el valor o la expresión que queremos usar.
#
# Guardemos 2 números en las variables `numero1` y `numero2`, realicemos la suma y usemos una `f-string` para mostrar los 3 valores:

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="7Yu0Trm8sTdL" outputId="7d81c509-a62f-4f0e-cb87-37b7221fc040"
numero1 = 18
numero2 = 34
resultado = numero1 + numero2
print(f"El resultado de la suma entre {numero1} y {numero2} da como resultado {resultado}")

# + [markdown] colab_type="text" id="XY1tQtumsnOb"
# Este es TU momento...

# + colab={} colab_type="code" id="QXpTQ7IrsqNu"


# + [markdown] colab_type="text" id="4MQMXEX9stxY"
# ## Ingreso de datos
#
# La función `input()` nos sirve para aceptar el ingreso de valores por teclado. Dentro de los paréntesis podemos escribir una cadena de texto para que el usuario visualice. La función devuelve el valor ingresado antes de presionar ENTER.

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="5No-i3VhtC_F" outputId="093128b0-2cb8-4653-ed60-1d83939c0db0"
x = input('Ingrese un número: ')

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="T47D57EEtIND" outputId="077d4afd-9dd5-4662-8763-7fa396ece83b"
x

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="cu23IXGLtJ1K" outputId="bb6ca90d-e307-472e-b0de-2e1e85e2e6c3"
type(x)

# + [markdown] colab_type="text" id="sXERgC8WtLvw"
# La función `input` SIEMPRE nos va a devolver una cadena de texto. Si queremos que ese valor sea un número, tenemos que convertirlo con `int()`, `float()` o `complex()` según sea nuestra intención.

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="zzBxiAuYtciv" outputId="4e5f8a4a-2339-46af-e6e0-fc0c1e1cec5f"
int(x)

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="B75iIiiRtfNq" outputId="2a2791a6-544b-4b19-914f-e7474514cf71"
float(x)

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="zX_pJEsOthwD" outputId="f68125ae-082b-47ad-a6e7-c79fbe225b24"
complex(x)

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="A0CTr71otqTD" outputId="07a58ad8-1d8e-4338-dc1a-02f09ddbf023"
x

# + [markdown] colab_type="text" id="UJwQd92ytkWQ"
# Notemos que acá nunca volvemos a guardar el valor de `x`, lo que se suele hacer es directamente llamar a la función que queremos y luego llamar dentro a `input()`.
#
# Por ejemplo, si quisieramos tener en `x` un entero:

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="gxLB-GV0t3bX" outputId="4c173149-8976-49fd-eb4d-14be533a3957"
x = int(input("Ingrese un número: "))

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="J-LlFb1ut-DM" outputId="6021a50e-7bfa-43dc-c998-460423310143"
x

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="0EhRXjZrt9U-" outputId="ecc873d0-194b-4152-9b44-8d302ef5a2b8"
type(x)

# + colab={"base_uri": "https://localhost:8080/", "height": 52} colab_type="code" id="NyGy_nSKTYJ3" outputId="ea411c54-1639-4688-f48c-64d0590b8d1c"
input("Ingrese su nombre: ")

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="sRrSlZACTpVm" outputId="f40956ff-52a0-4949-d410-dd22e3511fdf"
name = input("Ingrese su nombre: ")

# + colab={"base_uri": "https://localhost:8080/", "height": 34} colab_type="code" id="6ILEo_AsTwlE" outputId="fe3805fd-e1b0-46ba-ca6a-9d7d5d662267"
name

# + [markdown] colab_type="text" id="OSWZVQGzuCkF"
# Si ingresamos un valor que la función no puede convertir, nos tirará un error.

# + colab={"base_uri": "https://localhost:8080/", "height": 185} colab_type="code" id="TCwq95kIuGjJ" outputId="632d0262-0963-4be1-c6f4-bfc05470cf12"
x = int(input("Ingrese un número: "))

# + [markdown] colab_type="text" id="yOn1-lk9vLA5"
# ### Ejercicio:
#
# Pedile al usuario su nombre, guardalo en una variable y luego imprimí un mensaje que salude al usuario:

# + colab={} colab_type="code" id="XJisSBTOvX4-"


StarcoderdataJupyterScriptsDedupFiltered