diff --git a/02 - Variables y Tipos de Datos/Prep_Course_Homework_02-Resuelto Clase copy.ipynb b/02 - Variables y Tipos de Datos/Prep_Course_Homework_02-Resuelto Clase copy.ipynb new file mode 100644 index 000000000..713981e3d --- /dev/null +++ b/02 - Variables y Tipos de Datos/Prep_Course_Homework_02-Resuelto Clase copy.ipynb @@ -0,0 +1,863 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Variables" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1) Crear una variable que contenga un elemento del conjunto de números enteros y luego imprimir por pantalla" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "X = 1\n", + "Y = 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2) Imprimir el tipo de dato de la constante 8.5" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "float" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(8.5)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 2\n" + ] + } + ], + "source": [ + "print(X,Y) #se puede print(x) print(y) o también prin (x,y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3) Imprimir el tipo de dato de la variable creada en el punto 1" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n" + ] + } + ], + "source": [ + "print (type(X))\n", + "print (type(Y))" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "type() takes 1 or 3 arguments", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[16], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mtype\u001b[39;49m(X,Y))\n", + "\u001b[1;31mTypeError\u001b[0m: type() takes 1 or 3 arguments" + ] + } + ], + "source": [ + "print(type(X,Y))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4) Crear una variable que contenga tu nombre" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Katherin\n" + ] + } + ], + "source": [ + "minombre=\"Katherin\"\n", + "print(minombre)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "5) Crear una variable que contenga un número complejo" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(4+15j)\n" + ] + } + ], + "source": [ + "numero_complejo= 4+15j\n", + "print(numero_complejo)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "6) Mostrar el tipo de dato de la variable crada en el punto 5" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print(type(numero_complejo))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "7) Crear una variable que contenga el valor del número Pi redondeado a 4 decimales" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.141592\n" + ] + } + ], + "source": [ + "pi=3.141592\n", + "print(pi)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.1416\n" + ] + } + ], + "source": [ + "print(round(pi,4))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "\n", + "pi2 = math.pi\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3.141592653589793" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pi2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "8) Crear una variable que contenga el valor 'True' y otra que contenga el valor True. ¿Se trata de lo mismo?" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n" + ] + } + ], + "source": [ + "a=\"True\"\n", + "b= True\n", + "print(type(a))\n", + "print(type(b))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "No se trata de lo mismo pues todo valor que se encuentre dentro de las comillas es una cadena de valores alfanumericos" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "9) Imprimir el tipo de dato correspondientes a las variables creadas en el punto 9" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "punto9=25*9\n", + "print(type(punto9))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "10) Asignar a una variable, la suma de un número entero y otro decimal" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "23.2\n" + ] + } + ], + "source": [ + "suma=8+15.2\n", + "print(suma)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "11) Realizar una operación de suma de números complejos" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(11+323j)\n" + ] + } + ], + "source": [ + "compl1= 5+236j\n", + "compl2= 6+87j\n", + "print(compl1+compl2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "12) Realizar una operación de suma de un número real y otro complejo" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(10+98j)\n" + ] + } + ], + "source": [ + "real=5\n", + "compl3= 5+98j\n", + "print(real+compl3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "13) Realizar una operación de multiplicación" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "625\n" + ] + } + ], + "source": [ + "print(25*25)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "14) Mostrar el resultado de elevar 2 a la octava potencia" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "256\n" + ] + } + ], + "source": [ + "print(2**8)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "15) Obtener el cociente de la división de 27 entre 4 en una variable y luego mostrarla" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6.75\n" + ] + } + ], + "source": [ + "print(27/4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "16) De la división anterior solamente mostrar la parte entera" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6\n" + ] + } + ], + "source": [ + "print(27//4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "17) De la división de 27 entre 4 mostrar solamente el resto" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n" + ] + } + ], + "source": [ + "print(27%4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "18) Utilizando como operandos el número 4 y los resultados obtenidos en los puntos 16 y 17. Obtener 27 como resultado" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "27\n" + ] + } + ], + "source": [ + "print(6*4+3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "19) Utilizar el operador \"+\" en una operación donde intervengan solo variables alfanuméricas" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hola amor\n" + ] + } + ], + "source": [ + "print(\"hola\"+\" amor\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "20) Evaluar si \"2\" es igual a 2. ¿Por qué ocurre eso?" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "False\n" + ] + } + ], + "source": [ + "print(\"2\"==2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "21) Utilizar las funciones de cambio de tipo de dato, para que la validación del punto 20 resulte verdadera" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "print(int(\"2\")==2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "22) ¿Por qué arroja error el siguiente cambio de tipo de datos? a = float('3,8')" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "float expected at most 1 argument, got 2", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[39], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mfloat\u001b[39;49m(\u001b[39m3\u001b[39;49m,\u001b[39m8\u001b[39;49m))\n", + "\u001b[1;31mTypeError\u001b[0m: float expected at most 1 argument, got 2" + ] + } + ], + "source": [ + "print(float(3,8))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "por la coma, para décimales sólo se puede utilizar el punto" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "23) Crear una variable con el valor 3, y utilizar el operador '-=' para modificar su contenido" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [], + "source": [ + "valor3=3\n" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "valor3-=1" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2\n" + ] + } + ], + "source": [ + "print(valor3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "24) Realizar la operacion 1 << 2 ¿Por qué da ese resultado? ¿Qué es el sistema de numeración binario?" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4\n" + ] + } + ], + "source": [ + "print(1<<2)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "50>>3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "25) Realizar la operación 2 + '2' ¿Por qué no está permitido? ¿Si los dos operandos serían del mismo tipo, siempre arrojaría el mismo resultado?" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "unsupported operand type(s) for +: 'int' and 'str'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[2], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m2\u001b[39;49m\u001b[39m+\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39m2\u001b[39;49m\u001b[39m\"\u001b[39;49m)\n", + "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'" + ] + } + ], + "source": [ + "print(2+\"2\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n" + ] + } + ], + "source": [ + "print(type(2))\n", + "print(type(\"2\"))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "No sé puede porque un valor es string y el otr int " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "26) Realizar una operación válida entre valores de tipo entero y string" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6450\n" + ] + } + ], + "source": [ + "print(258*int(\"25\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hola Hola Hola 3 veces\n" + ] + } + ], + "source": [ + "uno=3\n", + "dos= \"Hola \"\n", + "print(uno*dos + str(uno)+\" veces\")" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.2" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/02 - Variables y Tipos de Datos/prueba.ipynb b/02 - Variables y Tipos de Datos/prueba.ipynb new file mode 100644 index 000000000..0495dc481 --- /dev/null +++ b/02 - Variables y Tipos de Datos/prueba.ipynb @@ -0,0 +1,861 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Variables" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1) Crear una variable que contenga un elemento del conjunto de números enteros y luego imprimir por pantalla" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "X = 1\n", + "Y = 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2) Imprimir el tipo de dato de la constante 8.5" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "float" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(8.5)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 2\n" + ] + } + ], + "source": [ + "print(X,Y) #se puede print(x) print(y) o también prin (x,y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3) Imprimir el tipo de dato de la variable creada en el punto 1" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n" + ] + } + ], + "source": [ + "print (type(X))\n", + "print (type(Y))" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "type() takes 1 or 3 arguments", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[16], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mtype\u001b[39;49m(X,Y))\n", + "\u001b[1;31mTypeError\u001b[0m: type() takes 1 or 3 arguments" + ] + } + ], + "source": [ + "print(type(X,Y))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4) Crear una variable que contenga tu nombre" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Katherin\n" + ] + } + ], + "source": [ + "minombre=\"Katherin\"\n", + "print(minombre)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "5) Crear una variable que contenga un número complejo" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(4+15j)\n" + ] + } + ], + "source": [ + "numero_complejo= 4+15j\n", + "print(numero_complejo)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "6) Mostrar el tipo de dato de la variable crada en el punto 5" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print(type(numero_complejo))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "7) Crear una variable que contenga el valor del número Pi redondeado a 4 decimales" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.141592\n" + ] + } + ], + "source": [ + "pi=3.141592\n", + "print(pi)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.1416\n" + ] + } + ], + "source": [ + "print(round(pi,4))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "\n", + "pi2 = math.pi\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3.141592653589793" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pi2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "8) Crear una variable que contenga el valor 'True' y otra que contenga el valor True. ¿Se trata de lo mismo?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#ESTO ES UNA PRUEBA" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n" + ] + } + ], + "source": [ + "a=\"True\"\n", + "b= True\n", + "print(type(a))\n", + "print(type(b))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "No se trata de lo mismo pues todo valor que se encuentre dentro de las comillas es una cadena de valores alfanumericos" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "9) Imprimir el tipo de dato correspondientes a las variables creadas en el punto 9" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "punto9=25*9\n", + "print(type(punto9))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "10) Asignar a una variable, la suma de un número entero y otro decimal" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "23.2\n" + ] + } + ], + "source": [ + "suma=8+15.2\n", + "print(suma)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "11) Realizar una operación de suma de números complejos" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(11+323j)\n" + ] + } + ], + "source": [ + "compl1= 5+236j\n", + "compl2= 6+87j\n", + "print(compl1+compl2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "12) Realizar una operación de suma de un número real y otro complejo" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(10+98j)\n" + ] + } + ], + "source": [ + "real=5\n", + "compl3= 5+98j\n", + "print(real+compl3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "13) Realizar una operación de multiplicación" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "625\n" + ] + } + ], + "source": [ + "print(25*25)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "14) Mostrar el resultado de elevar 2 a la octava potencia" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "256\n" + ] + } + ], + "source": [ + "print(2**8)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "15) Obtener el cociente de la división de 27 entre 4 en una variable y luego mostrarla" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6.75\n" + ] + } + ], + "source": [ + "print(27/4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "16) De la división anterior solamente mostrar la parte entera" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6\n" + ] + } + ], + "source": [ + "print(27//4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "17) De la división de 27 entre 4 mostrar solamente el resto" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n" + ] + } + ], + "source": [ + "print(27%4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "18) Utilizando como operandos el número 4 y los resultados obtenidos en los puntos 16 y 17. Obtener 27 como resultado" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "27\n" + ] + } + ], + "source": [ + "print(6*4+3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "19) Utilizar el operador \"+\" en una operación donde intervengan solo variables alfanuméricas" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hola amor\n" + ] + } + ], + "source": [ + "print(\"hola\"+\" amor\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "20) Evaluar si \"2\" es igual a 2. ¿Por qué ocurre eso?" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "False\n" + ] + } + ], + "source": [ + "print(\"2\"==2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "21) Utilizar las funciones de cambio de tipo de dato, para que la validación del punto 20 resulte verdadera" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4\n" + ] + } + ], + "source": [ + "print(int(\"2\")+2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "22) ¿Por qué arroja error el siguiente cambio de tipo de datos? a = float('3,8')" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "float expected at most 1 argument, got 2", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[39], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mfloat\u001b[39;49m(\u001b[39m3\u001b[39;49m,\u001b[39m8\u001b[39;49m))\n", + "\u001b[1;31mTypeError\u001b[0m: float expected at most 1 argument, got 2" + ] + } + ], + "source": [ + "print(float(3,8))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "por la coma, para décimales sólo se puede utilizar el punto" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "23) Crear una variable con el valor 3, y utilizar el operador '-=' para modificar su contenido" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [], + "source": [ + "valor3=3\n" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "valor3-=1" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2\n" + ] + } + ], + "source": [ + "print(valor3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "24) Realizar la operacion 1 << 2 ¿Por qué da ese resultado? ¿Qué es el sistema de numeración binario?" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4\n" + ] + } + ], + "source": [ + "print(1<<2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "25) Realizar la operación 2 + '2' ¿Por qué no está permitido? ¿Si los dos operandos serían del mismo tipo, siempre arrojaría el mismo resultado?" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "unsupported operand type(s) for +: 'int' and 'str'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[2], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m2\u001b[39;49m\u001b[39m+\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39m2\u001b[39;49m\u001b[39m\"\u001b[39;49m)\n", + "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'" + ] + } + ], + "source": [ + "print(2+\"2\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n" + ] + } + ], + "source": [ + "print(type(2))\n", + "print(type(\"2\"))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "No sé puede porque un valor es string y el otr int " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "26) Realizar una operación válida entre valores de tipo entero y string" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6450\n" + ] + } + ], + "source": [ + "print(258*int(\"25\"))" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.2" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/03 - Flujos de Control/Prep_Course_Homework_03-Resuelto Clase.ipynb b/03 - Flujos de Control/Prep_Course_Homework_03-Resuelto Clase.ipynb index ce4105c8d..978e642c6 100644 --- a/03 - Flujos de Control/Prep_Course_Homework_03-Resuelto Clase.ipynb +++ b/03 - Flujos de Control/Prep_Course_Homework_03-Resuelto Clase.ipynb @@ -131,7 +131,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -140,7 +140,7 @@ "0" ] }, - "execution_count": 6, + "execution_count": 1, "metadata": {}, "output_type": "execute_result" } @@ -34607,7 +34607,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.11.2" } }, "nbformat": 4, diff --git a/03 - Flujos de Control/Tarea2_Prep_Kathe.ipynb b/03 - Flujos de Control/Tarea2_Prep_Kathe.ipynb new file mode 100644 index 000000000..bf73b9b91 --- /dev/null +++ b/03 - Flujos de Control/Tarea2_Prep_Kathe.ipynb @@ -0,0 +1,468 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solución Tarea 2 Flujos de Control" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. Crear una variable que contenga un elemento del conjunto de números enteros y luego imprimir por pantalla si es mayor o menor a cero" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "La variable 25 es mayor a 0\n" + ] + } + ], + "source": [ + "x = 25\n", + "if (x>0):\n", + " print(\"La variable\",x, \"es mayor a 0\")\n", + "elif (x<0):\n", + " print(f\"La variable {x} es menor a 0\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "La variable -50 es menor a 0\n" + ] + } + ], + "source": [ + "x = -50\n", + "if (x>0):\n", + " print(\"La variable\" + \" x\" + \" es mayor a 0\")\n", + "elif (x<0):\n", + " print(f\"La variable {x} es menor a 0\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "La variable ingresada no es un número entero\n" + ] + } + ], + "source": [ + "#Ejemplo de Paula Villar\n", + "n = \"a\"\n", + "if (type(n) == int): \n", + " if (n<0): #si n es menor a 0\n", + " print(\"El valor\", n, \"es negativo\")\n", + " elif(n>0):# sino, n es mayor a cero\n", + " print(\"El valor\", n, \"es positivo\")\n", + " else: #los demás casos\n", + " print(\"El valor\", n, \"es igual a 0\")\n", + "else:\n", + " print(\"La variable ingresada no es un número entero\")\n", + " " + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. Crear dos variables y un condicional que informe si son del mismo tipo de dato" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "El tipo de variable de 2.5 es diferente al tipo de 3 porque 2.5 es de tipo y 3 es de tipo \n" + ] + } + ], + "source": [ + "a = 2.5\n", + "b = \"3\"\n", + "if (type(a)==type(b)):\n", + " print(f\"El tipo de variable de {a} es igual al tipo de variable {b}\")\n", + "elif (type(a)!=type(b)):\n", + " print(\"El tipo de variable de\", a, \"es diferente al tipo de\", b,\n", + " \"porque\",a, \"es de tipo\", type(a), \"y\", b, \"es de tipo\", type(b))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "El tipo de variable de 2.5 es igual al tipo de variable 3\n" + ] + } + ], + "source": [ + "a = 2.5\n", + "b = \"3\"\n", + "if (type(str(a))==type(b)):\n", + " print(f\"El tipo de variable de {a} es igual al tipo de variable {b}\")\n", + "elif (type(a)!=type(b)):\n", + " print(\"El tipo de variable de\", a, \"es diferente al tipo de\", b,\n", + " \"porque\",a, \"es de tipo\", type(a), \"y\", b, \"es de tipo\", type(b))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3. Para los valores enteros del 1 al 20, imprimir por pantalla si es par o impar" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 es impar\n", + "2 es par\n", + "3 es impar\n", + "4 es par\n", + "5 es impar\n", + "6 es par\n", + "7 es impar\n", + "8 es par\n", + "9 es impar\n", + "10 es par\n", + "11 es impar\n", + "12 es par\n", + "13 es impar\n", + "14 es par\n", + "15 es impar\n", + "16 es par\n", + "17 es impar\n", + "18 es par\n", + "19 es impar\n", + "20 es par\n" + ] + } + ], + "source": [ + "for n in range(1,21):\n", + " if (n%2 == 0):\n", + " print (f\"{n} es par\")\n", + " elif(n%2 != 0):\n", + " print (f\"{n} es impar\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "El número 2 es par\n", + "El número 4 es par\n", + "El número 6 es par\n", + "El número 8 es par\n", + "El número 10 es par\n", + "El número 12 es par\n", + "El número 14 es par\n", + "El número 16 es par\n", + "El número 18 es par\n", + "El número 20 es par\n", + "El número 1 es impar\n", + "El número 3 es impar\n", + "El número 5 es impar\n", + "El número 7 es impar\n", + "El número 9 es impar\n", + "El número 11 es impar\n", + "El número 13 es impar\n", + "El número 15 es impar\n", + "El número 17 es impar\n", + "El número 19 es impar\n" + ] + } + ], + "source": [ + "#este ejemplo es para hacer primeros los pares y luego los impares\n", + "for n in range(1,21):\n", + " if (n%2 == 0):\n", + " print (f\"El número {n} es par\")\n", + "for n in range(1,21):\n", + " if(n%2 != 0):\n", + " print (f\"El número {n} es impar\")" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "El numero 1 es impar\n", + "El numero 2 es par\n", + "El numero 3 es impar\n", + "El numero 4 es par\n", + "El numero 5 es impar\n", + "El numero 6 es par\n", + "El numero 7 es impar\n", + "El numero 8 es par\n", + "El numero 9 es impar\n", + "El numero 10 es par\n", + "El numero 11 es impar\n", + "El numero 12 es par\n", + "El numero 13 es impar\n", + "El numero 14 es par\n", + "El numero 15 es impar\n", + "El numero 16 es par\n", + "El numero 17 es impar\n", + "El numero 18 es par\n", + "El numero 19 es impar\n", + "El numero 20 es par\n" + ] + } + ], + "source": [ + "i = 1\n", + "while (i <= 20):\n", + " if (i % 2 == 0):\n", + " print(f'El numero {i} es par')\n", + " elif (i % 2 != 0):\n", + " print(f'El numero {i} es impar')\n", + " i = i + 1" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 es impar\n", + "2 es par\n", + "3 es impar\n", + "4 es par\n", + "5 es impar\n", + "6 es par\n", + "7 es impar\n", + "8 es par\n", + "9 es impar\n", + "10 es par\n", + "11 es impar\n", + "12 es par\n", + "13 es impar\n", + "14 es par\n", + "15 es impar\n", + "16 es par\n", + "17 es impar\n", + "18 es par\n", + "19 es impar\n", + "20 es par\n" + ] + } + ], + "source": [ + "i = 1\n", + "while (i <= 20):\n", + " if (i % 2 == 0):\n", + " print(f'{i} es par')\n", + " else:\n", + " print(f'{i} es impar')\n", + " i = i + 1" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4. En un ciclo for mostrar para los valores entre 0 y 5 el resultado de elevarlo a la potencia igual a 3" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "8\n", + "27\n", + "64\n", + "125\n" + ] + } + ], + "source": [ + "for n in range(0,6):\n", + " print(n**3)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Valor: 0 Elevado a la 3ra potencia: 0\n", + "Valor: 1 Elevado a la 3ra potencia: 1\n", + "Valor: 2 Elevado a la 3ra potencia: 8\n", + "Valor: 3 Elevado a la 3ra potencia: 27\n", + "Valor: 4 Elevado a la 3ra potencia: 64\n", + "Valor: 5 Elevado a la 3ra potencia: 125\n" + ] + } + ], + "source": [ + "for n in range(0, 6):\n", + " print('Valor:', str(n), ' Elevado a la 3ra potencia:', str(n**3))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "5. Crear una variable que contenga un número entero y realizar un ciclo for la misma cantidad de ciclos" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n" + ] + } + ], + "source": [ + "n = 7\n", + "for i in range(0, n):\n", + " print(i)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "11\n" + ] + } + ], + "source": [ + "n = 12\n", + "for i in range(0, n):\n", + " pass\n", + "print(i)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "n = 20\n", + "j = 1\n", + "for i in range(j, n):\n", + " continue" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "n = 2520" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.11.2" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Prep_Course_Homework_02-Resuelto Clase copy.ipynb b/Prep_Course_Homework_02-Resuelto Clase copy.ipynb new file mode 100644 index 000000000..4c19afb69 --- /dev/null +++ b/Prep_Course_Homework_02-Resuelto Clase copy.ipynb @@ -0,0 +1,824 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Variables" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1) Crear una variable que contenga un elemento del conjunto de números enteros y luego imprimir por pantalla" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "X = 1\n", + "Y = 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2) Imprimir el tipo de dato de la constante 8.5" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "float" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(8.5)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 2\n" + ] + } + ], + "source": [ + "print(X,Y) #se puede print(x) print(y) o también prin (x,y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3) Imprimir el tipo de dato de la variable creada en el punto 1" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n" + ] + } + ], + "source": [ + "print (type(X))\n", + "print (type(Y))" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "type() takes 1 or 3 arguments", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[16], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mtype\u001b[39;49m(X,Y))\n", + "\u001b[1;31mTypeError\u001b[0m: type() takes 1 or 3 arguments" + ] + } + ], + "source": [ + "print(type(X,Y))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4) Crear una variable que contenga tu nombre" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Katherin\n" + ] + } + ], + "source": [ + "minombre=\"Katherin\"\n", + "print(minombre)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "5) Crear una variable que contenga un número complejo" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(4+15j)\n" + ] + } + ], + "source": [ + "numero_complejo= 4+15j\n", + "print(numero_complejo)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "6) Mostrar el tipo de dato de la variable crada en el punto 5" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print(type(numero_complejo))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "7) Crear una variable que contenga el valor del número Pi redondeado a 4 decimales" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.141592\n" + ] + } + ], + "source": [ + "pi=3.141592\n", + "print(pi)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.1416\n" + ] + } + ], + "source": [ + "print(round(pi,4))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "\n", + "pi2 = math.pi\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3.141592653589793" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pi2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "8) Crear una variable que contenga el valor 'True' y otra que contenga el valor True. ¿Se trata de lo mismo?" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n" + ] + } + ], + "source": [ + "a=\"True\"\n", + "b= True\n", + "print(type(a))\n", + "print(type(b))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "No se trata de lo mismo pues todo valor que se encuentre dentro de las comillas es una cadena de valores alfanumericos" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "9) Imprimir el tipo de dato correspondientes a las variables creadas en el punto 9" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "punto9=25*9\n", + "print(type(punto9))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "10) Asignar a una variable, la suma de un número entero y otro decimal" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "23.2\n" + ] + } + ], + "source": [ + "suma=8+15.2\n", + "print(suma)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "11) Realizar una operación de suma de números complejos" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(11+323j)\n" + ] + } + ], + "source": [ + "compl1= 5+236j\n", + "compl2= 6+87j\n", + "print(compl1+compl2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "12) Realizar una operación de suma de un número real y otro complejo" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(10+98j)\n" + ] + } + ], + "source": [ + "real=5\n", + "compl3= 5+98j\n", + "print(real+compl3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "13) Realizar una operación de multiplicación" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "625\n" + ] + } + ], + "source": [ + "print(25*25)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "14) Mostrar el resultado de elevar 2 a la octava potencia" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "256\n" + ] + } + ], + "source": [ + "print(2**8)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "15) Obtener el cociente de la división de 27 entre 4 en una variable y luego mostrarla" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6.75\n" + ] + } + ], + "source": [ + "print(27/4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "16) De la división anterior solamente mostrar la parte entera" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6\n" + ] + } + ], + "source": [ + "print(27//4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "17) De la división de 27 entre 4 mostrar solamente el resto" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n" + ] + } + ], + "source": [ + "print(27%4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "18) Utilizando como operandos el número 4 y los resultados obtenidos en los puntos 16 y 17. Obtener 27 como resultado" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "27\n" + ] + } + ], + "source": [ + "print(6*4+3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "19) Utilizar el operador \"+\" en una operación donde intervengan solo variables alfanuméricas" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hola amor\n" + ] + } + ], + "source": [ + "print(\"hola\"+\" amor\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "20) Evaluar si \"2\" es igual a 2. ¿Por qué ocurre eso?" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "False\n" + ] + } + ], + "source": [ + "print(\"2\"==2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "21) Utilizar las funciones de cambio de tipo de dato, para que la validación del punto 20 resulte verdadera" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4\n" + ] + } + ], + "source": [ + "print(int(\"2\")+2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "22) ¿Por qué arroja error el siguiente cambio de tipo de datos? a = float('3,8')" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "float expected at most 1 argument, got 2", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[39], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mfloat\u001b[39;49m(\u001b[39m3\u001b[39;49m,\u001b[39m8\u001b[39;49m))\n", + "\u001b[1;31mTypeError\u001b[0m: float expected at most 1 argument, got 2" + ] + } + ], + "source": [ + "print(float(3,8))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "por la coma, para décimales sólo se puede utilizar el punto" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "23) Crear una variable con el valor 3, y utilizar el operador '-=' para modificar su contenido" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [], + "source": [ + "valor3=3\n" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "valor3-=1" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2\n" + ] + } + ], + "source": [ + "print(valor3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "24) Realizar la operacion 1 << 2 ¿Por qué da ese resultado? ¿Qué es el sistema de numeración binario?" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4\n" + ] + } + ], + "source": [ + "print(1<<2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "25) Realizar la operación 2 + '2' ¿Por qué no está permitido? ¿Si los dos operandos serían del mismo tipo, siempre arrojaría el mismo resultado?" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "unsupported operand type(s) for +: 'int' and 'str'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[2], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m2\u001b[39;49m\u001b[39m+\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39m2\u001b[39;49m\u001b[39m\"\u001b[39;49m)\n", + "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'" + ] + } + ], + "source": [ + "print(2+\"2\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n" + ] + } + ], + "source": [ + "print(type(2))\n", + "print(type(\"2\"))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "No sé puede porque un valor es string y el otr int " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "26) Realizar una operación válida entre valores de tipo entero y string" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6450\n" + ] + } + ], + "source": [ + "print(258*int(\"25\"))" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.2" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}