dia1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mi primer encuentro con Python\n",
    "\n",
    "- Hagamos un Hola Mundo\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola Mundo\n"
     ]
    }
   ],
   "source": [
    "print(\"Hola Mundo\") \n",
    "# esta linea no se ejecuta es un comentario\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables \n",
    "\n",
    "Las variables son espacios en la memoria de la computadora en los cuales podemos guardar datos durante la ejecucion de nuestro programa. \n",
    "\n",
    "A estos espacios de memoria les podemos poner nombres por medio de los cuales podemos acceder mas tarde. \n",
    "\n",
    "Entre las buenas practicas para nombras las variables tenemos: \n",
    "\n",
    "- usar minusculas \n",
    "- separar las palabras con guiones evitando espacios \n",
    "- no usar palabras reservadas como nombres de variables\n",
    "- a la forma de nombrar variables en python se le llama snake_case \n",
    "- evitar usar simbolos al establecer nombres de variables\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mbaeichapa\n",
      "Hola Mundo\n"
     ]
    }
   ],
   "source": [
    "# variables \n",
    "\n",
    "saludo = \"Mbaeichapa\" #la variable saludo toma el valor Mbaeichapa \n",
    "print(saludo) \n",
    "saludo = \"Hola Mundo\" #se reasigna un valor nuevo a la variable\n",
    "print(saludo)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Orden de ejecucion \n",
    "\n",
    "Observacion: La ejecucion se da linea por linea\n",
    "\n",
    "Todos los comandos se ejecutan en el orden en que se escriben"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tipos de datos \n",
    "\n",
    "- Dato tipo texto \n",
    "- Dato tipo numerico entero y decimal \n",
    "- Boolean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "2.3\n",
      "Despensa Lali\n",
      "<class 'int'>\n",
      "<class 'str'>\n",
      "<class 'bool'>\n",
      "False\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "numero_1 = 1 # tipo de datos numerico \n",
    "\n",
    "nombre_depensa = 'Despensa Lali' #dato tipo texto comillas sea simple o doble string --> str\n",
    "\n",
    "cantidad_unitaria_frutas = 10 # enteros integer --> int \n",
    "peso_de_frutas = 2.300 #gramos de sandia numero decimal --> float \n",
    "\n",
    "tienda_abierta_miercoles = True # Boolean --> bool \n",
    "tienda_abierta_feriado = False # Boolean --> bool \n",
    "\n",
    "print(cantidad_unitaria_frutas)\n",
    "print(peso_de_frutas)\n",
    "print(nombre_depensa)\n",
    "\n",
    "print(type(cantidad_unitaria_frutas))\n",
    "print(type(nombre_depensa))\n",
    "#Consigna imprimir el tipo de variable \n",
    "print(type(tienda_abierta_feriado))\n",
    "print(tienda_abierta_feriado)\n",
    "print(type(30))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mini challenge\n",
    "\n",
    "Escribir una variable nombre_companhero y asignar el nombre del companhero de al lado. E imprimir "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Angel Barreto\n"
     ]
    }
   ],
   "source": [
    "nombre_companhero = \"Angel Barreto\"\n",
    "print(nombre_companhero)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Operadores aritmeticos - con y sin variables\n",
    "\n",
    "Python permite realizar operaciones matematicas como una calculadora y para visualizar usamos print()\n",
    "\n",
    "\n",
    "Reglas de la precedencia de operadores\n",
    "1. Los paréntesis tienen la mayor precedencia y pueden usarse para forzar un orden.\n",
    "2. La siguiente precedencia la tienen las multiplicaciones y divisiones.\n",
    "3. La siguiente precedencia la tienen las sumas y restas.\n",
    "4. Los operadores con la misma precedencia se evalúan de izquierda a derecha (de arriba hacia abajo para operadores en una misma línea)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n",
      "10\n",
      "5.0\n",
      "5\n",
      "5\n",
      "3\n",
      "3\n",
      "16\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "print(5 * 5) # esto es una multiplicacion \n",
    "print(5 + 5) # esto es una suma \n",
    "print(10 / 2 ) # esto es una division \n",
    "print(10 // 2 ) # esta es una division entera \n",
    "print(10-5) #esta es una resta \n",
    "\n",
    "primer_numero = 5 + 5\n",
    "segundo_numero = 13 \n",
    "\n",
    "print(segundo_numero - primer_numero) \n",
    "\n",
    "resultado_resta = segundo_numero - primer_numero\n",
    "\n",
    "print(resultado_resta)\n",
    "\n",
    "# Python obedece a la regla de matematica de la precedencia de operadores \n",
    "\n",
    "# Ejemplo de precedencia de operadores \n",
    "\n",
    "print((2+2)*4) # con parentesis se modifica el orden de las operaciones el resultado es 16\n",
    "\n",
    "print(2+2*4) # el resultado es 10\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "33000\n"
     ]
    }
   ],
   "source": [
    "# Despensa Lali quiere un programa que le calcule el precio \n",
    "\n",
    "# Ejemplo de programa requerido que calcule el gasto de la compra en la despensa \n",
    "# Dato general = Jorge va a la despensa y compra zanahorias mas papas cuanto gasta \n",
    "\n",
    "\"\"\" esto es un comentario multilinea \"\"\"\n",
    "\n",
    "precio_zanahoria = 15000 \n",
    "precio_papas = 18000 \n",
    "\n",
    "gasto_total = precio_zanahoria + precio_papas\n",
    "\n",
    "print(gasto_total)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge \n",
    "\n",
    "Suma: asignar dos números en dos variables diferentes `cantidad_de_manzanas` y `cantidad_de_naranjas`. Luego sumar ambas variables en `cantidad_de_frutas`. Imprimir la última variable.\n",
    "\n",
    "Resta: asignar un valor numérico a la variable `frutas_vendidas`. Luego, asignar la resta entre `cantidad_de_frutas` y `frutas_vendidas` a la variable `frutas_restantes`. Imprimir la última variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35\n",
      "27\n"
     ]
    }
   ],
   "source": [
    "cantidad_de_manzanas = 15\n",
    "cantidad_de_naranjas = 20\n",
    "\n",
    "cantidad_de_frutas = cantidad_de_manzanas + cantidad_de_naranjas\n",
    "\n",
    "print(cantidad_de_frutas)\n",
    "\n",
    "frutas_vendidas = 8\n",
    "frutas_restantes = cantidad_de_frutas - frutas_vendidas\n",
    "\n",
    "print (frutas_restantes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Desafio de Suma\n",
      "Las frutas que hay son: 54\n",
      "Desafio de Resta\n",
      "Las frutas vendidas fueron: 27\n"
     ]
    }
   ],
   "source": [
    "print(\"Desafio de Suma\")\n",
    "cantidad_de_manzanas = 24\n",
    "cantidad_de_naranjas = 30\n",
    "cantidad_de_frutas = cantidad_de_manzanas + cantidad_de_naranjas\n",
    "print(\"Las frutas que hay son:\", cantidad_de_frutas)\n",
    "\n",
    "\n",
    "print(\"Desafio de Resta\")\n",
    "frutas_vendidas = 12 + 15\n",
    "frutas_restantes = cantidad_de_frutas - frutas_vendidas\n",
    "print(\"Las frutas vendidas fueron:\", frutas_restantes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Juguemos con texto: Concatenacion \n",
    "\n",
    "- Los textos son cadenas de caracteres \n",
    "- Los textos van entre comillas simples o dobles a diferencia de otros tipos de datos "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ClaudiaMelgarejo  cvmelgarejo\n",
      "Claudia Melgarejo  cvmelgarejo\n",
      "Hola me llamo Claudia y mi apellido es Melgarejo  y mi edad 15\n",
      "Hola mi nombre es Claudiay tengo 15anhos\n"
     ]
    }
   ],
   "source": [
    "#Para usar la concatenacion podemos usar el signo + para unir dos cadenas de texto \n",
    "# Lo que hacemos con la concatenacion es fusionar dos string en un unico objeto string \n",
    "\n",
    "nombre = \"Claudia\"\n",
    "apellido = \"Melgarejo \"\n",
    "github = \"cvmelgarejo\"\n",
    "edad = 15 \n",
    "\n",
    "# Textos + Variables(str)\n",
    "\n",
    "print(nombre + apellido + \" \" + github) #concatenacion \n",
    "print(nombre,apellido,github) #las comas separan elementos \n",
    "\n",
    "# format que se simboliza con una f \n",
    "# Usando las cadenas F para concatenar strings en Python metodo lo que hacemos es darle formato \n",
    "\n",
    "print(f\"Hola me llamo {nombre} y mi apellido es {apellido} y mi edad {edad}\") # llaves \n",
    "\n",
    "# el format ignora el tipo de dato a diferencia de concatenar con el + \n",
    "# diferentes tipos de datos no se pueden concatenar se debe hacer un paso mas \n",
    "\n",
    "print(\"Hola mi nombre es \" + nombre + \"y tengo \" +  str(edad) + \"anhos\" ) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Challenge \n",
    "\n",
    "Asignar el nombre y el apellido de tu compañera/o a las variables nombre y apellido. Luego, imprimir una frase, utilizando las variables.\n",
    "EJEMPLO: \"Hola. Me llamo Claudia Melgarejo. Mucho gusto.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola. Me llamo David Paniagua\n",
      "Hola mi nombre es David Paniagua\n"
     ]
    }
   ],
   "source": [
    "nombre = \"David\" \n",
    "apellido = \"Paniagua\"\n",
    "\n",
    "\n",
    "print(f\"Hola. Me llamo {nombre} {apellido}\") # F sirve para introducir variables dentro de un texto\n",
    "\n",
    "print(\"Hola mi nombre es\",nombre,apellido) # Concatenacion clasica, no hacen falta las llaves, la coma sirvió para espacio. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola Me llamo Sofia Aguayo\n",
      "Hola Me llamo Sofia Aguayo\n",
      "Hola Me llamo Sofia Aguayo\n"
     ]
    }
   ],
   "source": [
    "nombre_uno = \"Sofia\" \n",
    "apellido= \"Aguayo\"\n",
    "\n",
    "print(f\"Hola Me llamo {nombre_uno} {apellido}\")\n",
    "\n",
    "print(\"Hola Me llamo\" +\" \"+nombre_uno+\" \"+apellido)\n",
    "\n",
    "print(\"Hola Me llamo\",nombre_uno,apellido)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Obteniendo datos del usuario \n",
    "\n",
    "input( ) pedir informacion interactuando con el usuario "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alexandra\n"
     ]
    }
   ],
   "source": [
    "# Hacer un programa que solicite un nombre al usuario e imprimir \n",
    "\n",
    "nombre_usuario = input(\"Ingresar nombre usuario\")\n",
    "print(nombre_usuario)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000\n",
      "2000\n",
      "3000\n"
     ]
    }
   ],
   "source": [
    "# str() se usa para convertir un valor a texto \n",
    "# int() se utiliza para convertir un valor a numero\n",
    "\n",
    "# Despensa Lali quiere un programa que le calcule el costos total de la compra y que los usuarios ingresen los costos de los productos\n",
    "\n",
    "#establezco el input para el producto uno \n",
    "producto_uno = input(\"Ingresa el costo del producto uno\")\n",
    "print(producto_uno)\n",
    "#establezco el input para el producto dos \n",
    "producto_dos = input(\"ingresa el costo del producto dos\")\n",
    "print(producto_dos)\n",
    "\n",
    "costo_total = int(producto_uno) + int(producto_dos)\n",
    "print(costo_total)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Challenge\n",
    "\n",
    "Solicitar al usuario ingresar dos números y almacenarlos en dos variables. Luego, imprimir la suma de los dos números."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40000\n",
      "2000\n",
      "42000\n"
     ]
    }
   ],
   "source": [
    "ingrese_uno=int(input(\"ingrese primer valor\"))\n",
    "print(ingrese_uno)\n",
    "ingrese_dos=int(input(\"ingrese segundo valor\"))\n",
    "print(ingrese_dos)\n",
    "suma_total=ingrese_uno+ingrese_dos\n",
    "print(suma_total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Función personalizada vs función built-in \n",
    "\n",
    "La Funcion es un bloque de codigo disenhado para que realice una tarea en particular, asi mismo \n",
    "\n",
    "- Tenemos que las built-in son las funciones predeterminadas que estuvimos utilizando como type() o print()\n",
    "- Pero tambien tenemos que nosotros podemos hacer nuestras propias funciones \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola Mundo\n",
      "Mbaeichapa\n",
      "Hello World\n",
      "Hola Mundo\n",
      "Mbaeichapa\n",
      "Hello World\n",
      "Hola Mundo\n",
      "Mbaeichapa\n",
      "Hello World\n",
      "Hola Mundo\n",
      "Mbaeichapa\n",
      "Hello World\n",
      "Hola Mundo\n",
      "Mbaeichapa\n",
      "Hello World\n",
      "Hola Mundo\n",
      "Mbaeichapa\n",
      "Hello World\n",
      "Hola Mundo\n",
      "Mbaeichapa\n",
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "# Crear una funcion saludar que me imprima un saludo en 3 idiomas \n",
    "\n",
    "#sin funcion \n",
    "print(\"Hola Mundo\")\n",
    "print(\"Mbaeichapa\")\n",
    "print(\"Hello World\")\n",
    "\n",
    "\n",
    "def imprimir_saludos(): #definir el nombre de la funcion \n",
    "    print(\"Hola Mundo\") #instrucciones de la funcion \n",
    "    print(\"Mbaeichapa\")\n",
    "    print(\"Hello World\")\n",
    "imprimir_saludos() # primer llamado a la funcion\n",
    "imprimir_saludos() #segundo llamado \n",
    "imprimir_saludos() # tercer llamado\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge \n",
    "\n",
    "Crear una función de un proceso que se les ocurra que tenga varios pasos.\n",
    "Ejecutar la función 3 veces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Abeja\n",
      "Oso\n",
      "Casa\n"
     ]
    }
   ],
   "source": [
    "# solucion de un companhero \n",
    "\n",
    "Nombre_A = \"Abeja\"\n",
    "Nombre_B = \"Oso\"\n",
    "Nombre_C = \"Casa\"\n",
    "\n",
    "def Nombre_1():\n",
    "    print (Nombre_A)\n",
    "    print (Nombre_B)\n",
    "    print (Nombre_C)\n",
    "Nombre_1()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.4 64-bit",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.4"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}