NOTA:
SÓLO EL HACER Y EL HACER, LOGRARÁ QUE ADQUIERAS UNA HABILIDAD.
POR ESO A ESTA SECCIÓN SE LE LLAMA GIMNASIO.
SÓLO EL HACER Y EL HACER, LOGRARÁ QUE ADQUIERAS UNA HABILIDAD.
POR ESO A ESTA SECCIÓN SE LE LLAMA GIMNASIO.
GIMNASIO PYTHON BÁSICOEsto no es una guía de las librerías de Python. Este GYM, pretende que usted experimente con Python desde distintos ángulos, para que pueda empezar a desarrollar habilidades de programación. Si usted ya cubrió partes de las secciones de pseudocódigo en el texto de Pensamiento Algorítmico, le quedará mucho más simple abordar estas notas y los talleres de ejercicios asociados.
Estos ejercicios tampoco son una guía de instalación de Python, ni de ninguna otra herramienta sugerida. Tampoco enseña el uso de editores de texto o ambientes de programación. Ya está advertido. |
SESIÓN #1 DE EJERCITACIÓN: PREPARE SU GIMNASIO
- (Opcional)Cree una cuenta gratis en e entorno online http://Repl.it
- (Opcional)Conéctese a su cuenta replit. Use el botón para crear un nuevo repl, e indique que trabajará en Python. Si nunca ha trabajado en Python, es una buena forma de para comenzar a hacer sus primeros avances en el lenguaje. En replit encontrará muchas posibilidades para comenzar su proceso de aprendizaje.
- (Opcional)Cree una cuenta gratis en e entorno online PythonAnywhere. Dicho entorno le permitirá crear programas Python en una forma bastante sencilla. Brinda también la posibilidad de abrir consolas del sistema para trabajar directamente desde allí. Busque en google pythonanywhere, o vaya a https://www.pythonanywhere.com/
- Vaya a la línea de comandos de su sistema operativo. Escriba en la línea de comandos la palabra python y pulse enter. Si no le sacó error, usted ahora está al interior de una consola de Python. ¿Qué versión le aparece? Si su versión es inferior a 3, usted está ante una versión de Python muy vieja, y debería intentar instalar la última versión. Salga de Python escribiendo exit(), y pulsando la tecla Enter.
- Estando en la línea de comandos del sistema operativo, escriba python3 y pulse enter. -Si no le sacó error, usted ahora está al interior de una consola de Python. ¿Qué versión le aparece? Si su versión es inferior a 3.10, puede instalar la versión 3.10+. Eso debido a que, a partir de esa versión, hay algunas características interesantes para principiantes.
- (Opcional) Anaconda es posiblemente una de las mejores alternativas que hay para garantizar que se instala gran cantidad de librerías científicas útiles. Anaconda también es una forma de generar entornos de trabajo protegidos, en los cuales puede haber distintas versiones instaladas de distintos paquetes. Anaconda también trae preinstalado Spyder, un entorno de desarrollo Python muy completo: un IDE (Integrated Development Environment). También preinstala Jupyter, un excelente ambiente de trabajo para crear documentos interactivos mientras programa. Si lo desea, puede instalar desde la consola de Anaconda el lenguaje de programación R y R Studio. R es un lenguaje muy utilizado para analítica de datos debido a su orientación estadística. Busque en google Anaconda, o vaya a la dirección https://www.anaconda.com/products/individual. Instale anaconda en su máquina.
- (Recomendado) Descargue el editor Visual Studio Code. Este ambiente de programación es muy poderoso, y en él podrá trabajar en prácticamente cualquier lenguaje.
- (Recomendado) Si no tiene una, cree una cuenta en Google. Google Colaboratory es una muy buena herramienta para trabajo online con Python. Aunque su foco es Jupyter, podrá trabajar perfectamente código Python en el editor alternativo de código, con acceso a una inmensa cantidad de librerías.
- También podrá conectarse a Google Drive donde podrá tener todos sus datos, código, etc. Todo su código correrá en el servidor usando las cpu y gpu de los servidores de Google.
- Estando conectado en su cuenta de Google, busque Google Colaboratory, y vaya al enlace que lo llevará a su repositorio de documentos de programación.
PRIMEROS EXPERIMENTOS
-Es bueno reconocer con qué versión de Python estará trabajando sus programas o scripts durante el aprendizaje con este libro. Eso se debe a que se asume que si versión es 3.8 o superior, y de no serlo, algunos ejercicios podrían no funcionar.
Por tal motivo, vaya a la ventana de comandos de Python, sea en replit o en su computador, y escriba lo siguiente:
>>> import sys ; sys.version
Deberá aparecer algo similar a:
>>> sys.version
'3.11.3 (main, Apr 19 2023, 18:49:55) [Clang 14.0.6 ]'
El primer número que aparece es la versión. Identifique cuál es la suya.
Y téngala en cuenta para futuras referencias. Prefiera versiones superiores a 3.8.0.
-He aquí su primer truco en Python. Listar las palabras reservadas. Las palabras reservadas son aquellas exclusivas del lenguaje, por lo que no podrá usar ninguna de ellas como nombre de objeto (variable).
Siga los siguientes pasos y al final de cada comando pulse la tecla Enter.
>>> from keyword import kwlist; kwlist
Luego de pulsar la tecla Enter, obtendrá la siguiente lista:
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class',
'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if','import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try','while', 'with', 'yield']
El total de palabras reservadas puede ser consultado escribiendo:
>>> len(kwlist)
35
La versión actual del lenguaje python que se presenta, muestra 35 palabras reservadas. Es probable que no use todas las palabras en la primera parte del libro.
-He aquí otra consulta. Obtener la lista de los operadores y delimitadores de la versión que actualmente está usted usando en python
>>> from inspect import token
>>> token.__dict__['EXACT_TOKEN_TYPES'].keys()
dict_keys(['!=', '%', '%=', '&', '&=', '(', ')', '*', '**', '**=', '*=', '+', '+=', ',', '-', '-=', '->', '.', '...', '/', '//', '//=', '/=', ':', ':=', ';', '<', '<<', '<<=', '<=', '=', '==', '>', '>=', '>>', '>>=', '@', '@=', '[', ']', '^', '^=', '{', '|', '|=', '}', '~'])
El total de operadores y delimitadores puede ser consultado escribiendo:
>>>len(token.__dict__['EXACT_TOKEN_TYPES'].keys())
47
En realidad, se trata de una lista incompleta, ya que no presenta sino operadores y delimitadores representados por caracteres especiales. Los operadores lógicos and, or y not no aparecen representados.
Por tal motivo, vaya a la ventana de comandos de Python, sea en replit o en su computador, y escriba lo siguiente:
>>> import sys ; sys.version
Deberá aparecer algo similar a:
>>> sys.version
'3.11.3 (main, Apr 19 2023, 18:49:55) [Clang 14.0.6 ]'
El primer número que aparece es la versión. Identifique cuál es la suya.
Y téngala en cuenta para futuras referencias. Prefiera versiones superiores a 3.8.0.
-He aquí su primer truco en Python. Listar las palabras reservadas. Las palabras reservadas son aquellas exclusivas del lenguaje, por lo que no podrá usar ninguna de ellas como nombre de objeto (variable).
Siga los siguientes pasos y al final de cada comando pulse la tecla Enter.
>>> from keyword import kwlist; kwlist
Luego de pulsar la tecla Enter, obtendrá la siguiente lista:
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class',
'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if','import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try','while', 'with', 'yield']
El total de palabras reservadas puede ser consultado escribiendo:
>>> len(kwlist)
35
La versión actual del lenguaje python que se presenta, muestra 35 palabras reservadas. Es probable que no use todas las palabras en la primera parte del libro.
-He aquí otra consulta. Obtener la lista de los operadores y delimitadores de la versión que actualmente está usted usando en python
>>> from inspect import token
>>> token.__dict__['EXACT_TOKEN_TYPES'].keys()
dict_keys(['!=', '%', '%=', '&', '&=', '(', ')', '*', '**', '**=', '*=', '+', '+=', ',', '-', '-=', '->', '.', '...', '/', '//', '//=', '/=', ':', ':=', ';', '<', '<<', '<<=', '<=', '=', '==', '>', '>=', '>>', '>>=', '@', '@=', '[', ']', '^', '^=', '{', '|', '|=', '}', '~'])
El total de operadores y delimitadores puede ser consultado escribiendo:
>>>len(token.__dict__['EXACT_TOKEN_TYPES'].keys())
47
En realidad, se trata de una lista incompleta, ya que no presenta sino operadores y delimitadores representados por caracteres especiales. Los operadores lógicos and, or y not no aparecen representados.
Representación en otros sistemas
Para escribir en otros sistemas, tenemos que entender bien los sistemas. En Python, para escribir en hexadecimal usaremos el prefijo 0x, para escribir en octal el prefijo 0o o solo el 0, y para escribir en binario el prefijo 0b. Para escribir en decimal procedemos normalmente sin prefijo.
>>> 0xaa + 120 + 0o67756 * 0b101110111
10745540
En el ejemplo, el valor 0xaa es 170, el valor 0o67756 es 28654 en decimal, y el valor binario 0b101110111 corresponde a 375 decimal.
Como puede ver, la escritura de números enteros dependerá de sus preferencias, y de qué representación es más apropiada para el programador expresar la solución a un problema.
Sin importar en qué sistema trabaje, la representación interna será binaria. Sin embargo, cada que Python necesite mostrar un valor, lo hará en sistema decimal. Para presentar un valor en otros sistemas, usaremos las funciones bin(), oct() y hex() para representar un decimal en binario, octal o hexadecimal respectivamente.
>>> x=177
>>> (bin(x), oct(x), hex(x))
('0b10110001', '0261', '0xb1')
El tipo de estas representaciones son string, lo que significa que la tupla ahora no sontiene valores, sino una representación de los valores como cadena, lo que en realidad no tiene ya significado como número.
Convertir una string a entero decimal.
A pesar de lo anterior, una string que represente un número puede ser convertida al respectivo valor entero usando la función int( ). Solo se necesita que el número esté bien escrito dentro de la cadena, y que se le indique la base a la que se quiere convertir.
>>> x = 177
>>> t = (bin(x), oct(x), hex(x))
>>> t
('0b10110001', '0o261', '0xb1')
>>> int(t[0],2)
177
>>> int(t[1],8)
177
>>> int(t[2],16)
177
Convertir entre binario, hexadecimal y octal.
Dado que Podemos escribir números binarios, octales, decimales y hexadecimales, directamente, y dado que contamos con las funciones bin( ), oct( ) y hex( ) que nos entregan una representación string, podríamos obtener la representación de un sistema en el otro. Para entenderlo, solo basta con ejemplos simples de conversiones.
>>> hex(0b1101011101011)
'0x1aeb'
>>> bin(0xAA)
'0b10101010'
>>> oct(0b1101)
'0o15'
>>>
>>> 0xaa + 120 + 0o67756 * 0b101110111
10745540
En el ejemplo, el valor 0xaa es 170, el valor 0o67756 es 28654 en decimal, y el valor binario 0b101110111 corresponde a 375 decimal.
Como puede ver, la escritura de números enteros dependerá de sus preferencias, y de qué representación es más apropiada para el programador expresar la solución a un problema.
Sin importar en qué sistema trabaje, la representación interna será binaria. Sin embargo, cada que Python necesite mostrar un valor, lo hará en sistema decimal. Para presentar un valor en otros sistemas, usaremos las funciones bin(), oct() y hex() para representar un decimal en binario, octal o hexadecimal respectivamente.
>>> x=177
>>> (bin(x), oct(x), hex(x))
('0b10110001', '0261', '0xb1')
El tipo de estas representaciones son string, lo que significa que la tupla ahora no sontiene valores, sino una representación de los valores como cadena, lo que en realidad no tiene ya significado como número.
Convertir una string a entero decimal.
A pesar de lo anterior, una string que represente un número puede ser convertida al respectivo valor entero usando la función int( ). Solo se necesita que el número esté bien escrito dentro de la cadena, y que se le indique la base a la que se quiere convertir.
>>> x = 177
>>> t = (bin(x), oct(x), hex(x))
>>> t
('0b10110001', '0o261', '0xb1')
>>> int(t[0],2)
177
>>> int(t[1],8)
177
>>> int(t[2],16)
177
Convertir entre binario, hexadecimal y octal.
Dado que Podemos escribir números binarios, octales, decimales y hexadecimales, directamente, y dado que contamos con las funciones bin( ), oct( ) y hex( ) que nos entregan una representación string, podríamos obtener la representación de un sistema en el otro. Para entenderlo, solo basta con ejemplos simples de conversiones.
>>> hex(0b1101011101011)
'0x1aeb'
>>> bin(0xAA)
'0b10101010'
>>> oct(0b1101)
'0o15'
>>>
SESIÓN #2 DE EJERCITACIÓN: CALISTEMIA EN LA CONSOLA PYTHON
- Multiplique 8 * 8, pero expresando un número en binario y el otro en hexadecimal.
- Escriba la expresión 10*20*30, donde cada número está escrito en un sistema numérico distinto del decimal.
- Escriba dentro de paréntesis, separados por comas, cuatro datos enteros usando representación binaria, octal, hexadecimal y decimal. Guárdelo en una variable. Imprima la variable.
- Imprima la representación binaria de la primera posición de la tupla que creó. Use corchetes ( [ ] ) para referirse a la posición 0 de la variable.
- Imprima la representación octal de la tercera posición de la tupla que creó. Use corchetes ( [ ] ) para referirse a la posición 2 de la variable.
- Imprima la representación decimal de la segunda posición de la tupla que creó. Use corchetes ( [ ] ) para referirse a la posición 1 de la variable.
- Almacene en una tupla (meter entre paréntesis) las representaciones string del número 127 en 4 sistemas numéricos diferentes (las funciones oct(), bin() y hex() devuelven representaciones en cadena. Para una representación decimal, use str().
- Sobre la tupla anterior, convierta a entero el segundo valor, usando la función int( ).
- Sume el primer y tercer número de la tupla anterior.
- Convierta en papel el número -72 a binario usando complemento a 2, y verifique en Python su representación es la misma que usa Python. Investigue si nota alguna diferencia.
- Convierta a binario la representación hexadecimal del número 100.
- Convierta a decimal la representación binaria del número 200.
- Convierta a hexadecimal la representación binaria de sumar dos números cualquiera x , y.
- Usando el conocimiento que tiene sobre los dígitos que puede contener un número en cualquier base, diseñe cuatro números en bases 20, 25, 30, 35, represéntelo como string, y use el constructor int( ) con el número y la base para determinar el valor en decimal de cada uno de ellos.
- Determine el valor decimal del número ‘MARIA’en base 36, 26, 16 y 6. ¿Por qué se requieren más dígitos a medida que la base es más pequeña?
- Especule sobre la representación binaria teórica de la palabra ‘BINARIO’. Luego que ya tenga lista su hipótesis, copie la siguiente línea Python en la consola Python, y compruebE su hipótesis usando la expresión ''.join(bin(ord(d))[2:] for d in 'BINARIO')
ANTERS DE COMENZAR, UNA NOTA IMPORTANTE SOBRE DUNDERS
Todo objeto tiene funciones especiales que actúan sobre el objeto. Cuando los nombres de esas funciones comienzan por dos underscores (__) y terminan con otros dos underscores (__), son funciones que pueden ser apoyadas automáticamente por helpers de Python.
Pero igual son métodos que usted puede llamar directamente.
A estos métodos rodeados por doble underscore, se les conoce como Dunders por su double underscores (en inglés).
Por ejemplo, la función __len__( ) está presente en strings, tuplas, listas, diccionarios y sets. Lo puede comprobar imprimiendo el atributo __dir__ de esos objetos, o simplemente usando la función dir() del lenguaje, por ejemplo, dir(str), dir(list), dir(dict), dict(tuple), dict(set).
Eso significa que, si yo aplico el helper público len() a un objeto, se llama siempr el método específico __len__( ) según el objeto al que se le aplique: si lo aplico a una lista, a un set, o a un diccionario, me dirá cuántos elementos tiene, y si lo aplico a una string, me dirá cuántos caracteres tiene. De ese modo se conserva el propósito de los nombres dentro de los métodos.
Adicionalmente, las nuevas clases que se crean, podrán tener sus propios dunders que pueden ser invocados por las funciones helper estándar. Por ejemplo, si creo un tipo de dato camino, y a ese tipo de dato le pongo un dunder __len__( ) que indica la longitud del camino, se le podrá aplicar el helper público len( ).
Los operadores, también están asociados a dunders. Por ejemplo el operador aritmático mas(+), está asociado al dunder __add__(), que cuando se trata de números suma aritméticamente dos números, cuando se trata de strings las concatena y en nuestra clase camino podría sumar la distancia conjunta de dos caminos.
Todo objeto tiene funciones especiales que actúan sobre el objeto. Cuando los nombres de esas funciones comienzan por dos underscores (__) y terminan con otros dos underscores (__), son funciones que pueden ser apoyadas automáticamente por helpers de Python.
Pero igual son métodos que usted puede llamar directamente.
A estos métodos rodeados por doble underscore, se les conoce como Dunders por su double underscores (en inglés).
Por ejemplo, la función __len__( ) está presente en strings, tuplas, listas, diccionarios y sets. Lo puede comprobar imprimiendo el atributo __dir__ de esos objetos, o simplemente usando la función dir() del lenguaje, por ejemplo, dir(str), dir(list), dir(dict), dict(tuple), dict(set).
Eso significa que, si yo aplico el helper público len() a un objeto, se llama siempr el método específico __len__( ) según el objeto al que se le aplique: si lo aplico a una lista, a un set, o a un diccionario, me dirá cuántos elementos tiene, y si lo aplico a una string, me dirá cuántos caracteres tiene. De ese modo se conserva el propósito de los nombres dentro de los métodos.
Adicionalmente, las nuevas clases que se crean, podrán tener sus propios dunders que pueden ser invocados por las funciones helper estándar. Por ejemplo, si creo un tipo de dato camino, y a ese tipo de dato le pongo un dunder __len__( ) que indica la longitud del camino, se le podrá aplicar el helper público len( ).
Los operadores, también están asociados a dunders. Por ejemplo el operador aritmático mas(+), está asociado al dunder __add__(), que cuando se trata de números suma aritméticamente dos números, cuando se trata de strings las concatena y en nuestra clase camino podría sumar la distancia conjunta de dos caminos.
DISECCIÓN TENUE DEL LENGUAJE PYTHON
Python es un lenguaje con orientación a objetos (OOP) y de propósito general. No es un lenguaje diseñado para científicos, aunque hoy día es popular entre científicos. Debido a su orientación, prácticamente todo en Python es una clase que se instancia automáticamente como objeto. Un objeto es una instancia de una plantilla de objeto llamada clase, que contiene funciones que operan tradicionalmente sobre los datos del objeto. Los datos del objeto, en jerga OOP, se conoce como estado del objeto. Dada esta naturaleza, cualquier variable en Python es un objeto.
También, Python es un lenguaje de tipos dinámicos, lo que significa que el tipo no se declara, sino que se obtiene a medida que se crean variables durante la interpretación. Python es un lenguaje interpretado. El código de máquina necesario para correr en un procesador se traduce durante la ejecución y cualquier error de manejo de tipos será solo percibido cuando el programa corre y se ejecuta la línea con error; esto representa un riesgo que hay que vigilar con buenas pruebas y prácticas de programación.
En Python, el tipo asociado a una variable se establece al momento de su inicialización. Esto es, se debe crear un objeto del tipo concreto y la dirección del objeto se le entrega a la variable. Podemos indagar sobre el tipo de una variable usando la función type(objeto), o usando el atributo de clase __class__.
NOTA: Los ejemplos que se presentan en esta sección se corrieron en una consola de Python en Unix, con versión 3.8+ de Python.
>>> x = "Python es orientado a objetos"
>>> x.__class__
<class 'str'>
>>> type(x)
<class 'str'>
NOMBRE DE OBJETOS(VARIABLES)
En Python, todo nombre de variable, función, o instrucción es sensible a mayúsculas y minúsculas.
>>> A = 10
>>> a = 20
>>> (A , a)
(10, 20)
>>>
En el caso anterior, las dos variables A y a son diferentes.
Cualquier pequeña fluctuación en este sentido en una variable las hará diferentes.
>>> Kilogramo = 1000
>>> kilogramo = 1000
Las dos variables kilogramo y kilogramo son diferentes y pueden causar problemas.
Una variable tiene que comenzar con letra, o con guion bajo (underscore); en ningún momento una variable puede comenzar con un número.
Cualquier intento en este sentido se considera error de sintaxis.
>>> 3n = 20
File "<stdin>", line 1
3n = 20
^
SyntaxError: invalid syntax
>>>
El nombre de la variable puede combinar cualquier caracter, excepto caracteres especiales como $, #, @, el espacio, y delimitadores como la coma (,), el punto (.), el punto y coma (;) y los dos puntos (:).
También, Python es un lenguaje de tipos dinámicos, lo que significa que el tipo no se declara, sino que se obtiene a medida que se crean variables durante la interpretación. Python es un lenguaje interpretado. El código de máquina necesario para correr en un procesador se traduce durante la ejecución y cualquier error de manejo de tipos será solo percibido cuando el programa corre y se ejecuta la línea con error; esto representa un riesgo que hay que vigilar con buenas pruebas y prácticas de programación.
En Python, el tipo asociado a una variable se establece al momento de su inicialización. Esto es, se debe crear un objeto del tipo concreto y la dirección del objeto se le entrega a la variable. Podemos indagar sobre el tipo de una variable usando la función type(objeto), o usando el atributo de clase __class__.
NOTA: Los ejemplos que se presentan en esta sección se corrieron en una consola de Python en Unix, con versión 3.8+ de Python.
>>> x = "Python es orientado a objetos"
>>> x.__class__
<class 'str'>
>>> type(x)
<class 'str'>
NOMBRE DE OBJETOS(VARIABLES)
En Python, todo nombre de variable, función, o instrucción es sensible a mayúsculas y minúsculas.
>>> A = 10
>>> a = 20
>>> (A , a)
(10, 20)
>>>
En el caso anterior, las dos variables A y a son diferentes.
Cualquier pequeña fluctuación en este sentido en una variable las hará diferentes.
>>> Kilogramo = 1000
>>> kilogramo = 1000
Las dos variables kilogramo y kilogramo son diferentes y pueden causar problemas.
Una variable tiene que comenzar con letra, o con guion bajo (underscore); en ningún momento una variable puede comenzar con un número.
Cualquier intento en este sentido se considera error de sintaxis.
>>> 3n = 20
File "<stdin>", line 1
3n = 20
^
SyntaxError: invalid syntax
>>>
El nombre de la variable puede combinar cualquier caracter, excepto caracteres especiales como $, #, @, el espacio, y delimitadores como la coma (,), el punto (.), el punto y coma (;) y los dos puntos (:).
PALABRAS RESERVADAS.
Cada lenguaje cuenta con un conjunto de palabras reservadas que son estrictas del lenguaje, y que no pueden ser usadas como nombres de variables. La mejor forma de mantenerse al tanto de los nombres reservados en Python, es preguntarle a él mismo cuáles son. Python permite esta consulta de la siguiente manera:
>>> import keyword
>>> keyword.kwlist
Tan pronto pulse la tecla Enter, aparecerá la lista de palabras reservadas.
Deberá acostumbrarse a ellas, ya que son las que usará para escribir sus programas.
['False', 'None', 'True', and, 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', or, 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
>>>
Como se mencionó, este conjunto de palabras es reservado. Cualquier intento de usar alguna de estas palabras como nombre de variable, dará como resultado un error de sintaxis.
Cada lenguaje cuenta con un conjunto de palabras reservadas que son estrictas del lenguaje, y que no pueden ser usadas como nombres de variables. La mejor forma de mantenerse al tanto de los nombres reservados en Python, es preguntarle a él mismo cuáles son. Python permite esta consulta de la siguiente manera:
>>> import keyword
>>> keyword.kwlist
Tan pronto pulse la tecla Enter, aparecerá la lista de palabras reservadas.
Deberá acostumbrarse a ellas, ya que son las que usará para escribir sus programas.
['False', 'None', 'True', and, 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', or, 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
>>>
Como se mencionó, este conjunto de palabras es reservado. Cualquier intento de usar alguna de estas palabras como nombre de variable, dará como resultado un error de sintaxis.
OPERADORES NATIVOS PYTHON
Al igual que con las palaras reservadas, cada lenguaje cuenta con un conjunto de operadores predefinidos. Los operadores realmente son funciones que se aplican a los datos, pero que están pensados para que sea más natural para el usuario escribir esas operaciones.
También podemos preguntarle a Python cuáles son sus operadores predefinidos.
>>> from inspect import * ; token.__dict__['EXACT_TOKEN_TYPES']
{'!=': 28, '%': 24, '%=': 40, '&': 19, '&=': 41, '(': 7, ')': 8, '*': 16, '**': 35, '**=': 46, '*=': 38, '+': 14, '+=': 36, ',': 12, '-': 15, '-=': 37, '->': 51, '.': 23, '...': 52, '/': 17, '//': 47, '//=': 48, '/=': 39, ':': 11, ':=': 53, ';': 13, '<': 20, '<<': 33, '<<=': 44, '<=': 29, '=': 22, '==': 27, '>': 21, '>=': 30, '>>': 34, '>>=': 45, '@': 49, '@=': 50, '[': 9, ']': 10, '^': 32, '^=': 43, '{': 25, '|': 18, '|=': 42, '}': 26, '~': 31}
La consulta nos entrega una estructura un poco extraña que podremos entender más adelante, cuando conozcamos sobre el tipo de dato dictionary. En ese diccionario, aparecen los operadores posibles, acompañados de un número entero. Ese numero entero se usa para la generación de código intermedio, y no será discutido aquí, ya que no es necesario para programar con Python.
Al igual que con las palaras reservadas, cada lenguaje cuenta con un conjunto de operadores predefinidos. Los operadores realmente son funciones que se aplican a los datos, pero que están pensados para que sea más natural para el usuario escribir esas operaciones.
También podemos preguntarle a Python cuáles son sus operadores predefinidos.
>>> from inspect import * ; token.__dict__['EXACT_TOKEN_TYPES']
{'!=': 28, '%': 24, '%=': 40, '&': 19, '&=': 41, '(': 7, ')': 8, '*': 16, '**': 35, '**=': 46, '*=': 38, '+': 14, '+=': 36, ',': 12, '-': 15, '-=': 37, '->': 51, '.': 23, '...': 52, '/': 17, '//': 47, '//=': 48, '/=': 39, ':': 11, ':=': 53, ';': 13, '<': 20, '<<': 33, '<<=': 44, '<=': 29, '=': 22, '==': 27, '>': 21, '>=': 30, '>>': 34, '>>=': 45, '@': 49, '@=': 50, '[': 9, ']': 10, '^': 32, '^=': 43, '{': 25, '|': 18, '|=': 42, '}': 26, '~': 31}
La consulta nos entrega una estructura un poco extraña que podremos entender más adelante, cuando conozcamos sobre el tipo de dato dictionary. En ese diccionario, aparecen los operadores posibles, acompañados de un número entero. Ese numero entero se usa para la generación de código intermedio, y no será discutido aquí, ya que no es necesario para programar con Python.
FUNCIONES NATIVAS.
Sin considerar los cientos de librerías de Python que podrían ser usadas, y sin considerar aquellas que ya vienen con la instalación de Python en cualquier sistema, cuando Python es invocado y cargado, cargará obviamente sus palabras reservadas del lenguaje y operadores, que ya fueron consultados previamente.
Inicialmente, Python carga de forma automática una librería vital para el lenguaje. Esta librería, la cual es considerada parte nativa de Python, puede ser vista como un objeto, a su vez compuesto por un conjunto de métodos(funciones) de uso muy regular. La librería se llama builtins.
La librería builtins puede ser consultada con el comando dir( __builtins__ ). La raya que se muestra adelante y atrás de la palabra builtins, está en realidad compuesta de dos rayitas conocidas en inglés como 'underscore' (_). En español la traducción más común es 'guión bajo').
>>> [o for o in dir(__builtins__) if not o[0].isupper()]
['_', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'aiter', 'all', 'anext', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
El objeto __builtins__ contiene funciones nativas y de acceso a objetos especiales del lenguaje. También contiene aproximadamente 70 referencias a objetos especiales de Python (y que evitamos presentar para no ocupar espacio de forma innecesaria), casi todos para la gestión de error.
Las que quedan en la consulta son aquellas funciones nativas, que son de interés para comenzar a trabajar.
Para una salida completa de todo su contenido, escriba
>>> dir(__builtins__)
Como el objeto builtins siempre está cargado en memoria (es cargado de forma automática al iniciarse Python), debe ser que operación vital para el lenguaje. Funciones pertinentes al sistema de tipos de datos y conversiones incluyendo aspectos de gestión de clases, funciones de representación de datos en otros sistemas numéricos, funciones para consultar direcciones en memoria de los objetos, funciones de entrada y salida de datos, funciones de formato de datos, funciones para iterar colecciones, funciones del sistema, y algunas constantes con información sobre los módulos, e información importante para el sistema, como los valores fijos e inmutables False y True, y el valor None, que son constantes reservadas del lenguaje, pero que no se manejan dentro de la lista de palabras reservadas oficial que revisamos previamente por tratarse de valores.
Daremos un vistazo muy breve y sin detalles, por categorías.
IMPORTANTE: si usted se está tomando en serio el uso de Python, conocer estas funciones es clave para su trabajo con el lenguaje, pues le simplificará un poco más la escritura de muchas llamadas, lo que igualmente se reflejará en un código más legible. Entonces, si no conoce Python, escriba en un papel que esté a la mano, el comando dir(__builtins__). Ocasionalmente córralo, y trate de ver qué funciones de esas no usa, y trate de entenderlas y tener claro porqué no las usa. De ese modo mantendrá una visión más clara del lenguaje.
Funciones que son de apoyo, como help( ), y que permite consultar información sobre cualquier, tipo, o función, y la función dir( ) que permite enumerar la lista de atributos y métodos de un objeto o clase, o globals( ) y locals( ), que enumeras los objetos que están cargados en memoria a nivel global o local a un módulo, clase, método o función, son de gran ayuda en ambientes interactivos como Python. La función vars( ) es un sinónimo de globals( ).
La función compile( ), permite compilar un código fuente de Python desde un archivo o desde la memoria, para que luego pueda ser ejecutado o evaluado por las funciones eval( ) y exec( ), también disponibles.
Tenemos también la función id( ), que permite conocer la dirección en memoria de un objeto.
Otros objetos y funciones están disponibles en __builtins__ , como, por ejemplo, todas las clases para tipificación de errores. Sin embargo, no se contempla describirlas.
Sin considerar los cientos de librerías de Python que podrían ser usadas, y sin considerar aquellas que ya vienen con la instalación de Python en cualquier sistema, cuando Python es invocado y cargado, cargará obviamente sus palabras reservadas del lenguaje y operadores, que ya fueron consultados previamente.
Inicialmente, Python carga de forma automática una librería vital para el lenguaje. Esta librería, la cual es considerada parte nativa de Python, puede ser vista como un objeto, a su vez compuesto por un conjunto de métodos(funciones) de uso muy regular. La librería se llama builtins.
La librería builtins puede ser consultada con el comando dir( __builtins__ ). La raya que se muestra adelante y atrás de la palabra builtins, está en realidad compuesta de dos rayitas conocidas en inglés como 'underscore' (_). En español la traducción más común es 'guión bajo').
>>> [o for o in dir(__builtins__) if not o[0].isupper()]
['_', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'aiter', 'all', 'anext', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
El objeto __builtins__ contiene funciones nativas y de acceso a objetos especiales del lenguaje. También contiene aproximadamente 70 referencias a objetos especiales de Python (y que evitamos presentar para no ocupar espacio de forma innecesaria), casi todos para la gestión de error.
Las que quedan en la consulta son aquellas funciones nativas, que son de interés para comenzar a trabajar.
Para una salida completa de todo su contenido, escriba
>>> dir(__builtins__)
Como el objeto builtins siempre está cargado en memoria (es cargado de forma automática al iniciarse Python), debe ser que operación vital para el lenguaje. Funciones pertinentes al sistema de tipos de datos y conversiones incluyendo aspectos de gestión de clases, funciones de representación de datos en otros sistemas numéricos, funciones para consultar direcciones en memoria de los objetos, funciones de entrada y salida de datos, funciones de formato de datos, funciones para iterar colecciones, funciones del sistema, y algunas constantes con información sobre los módulos, e información importante para el sistema, como los valores fijos e inmutables False y True, y el valor None, que son constantes reservadas del lenguaje, pero que no se manejan dentro de la lista de palabras reservadas oficial que revisamos previamente por tratarse de valores.
Daremos un vistazo muy breve y sin detalles, por categorías.
IMPORTANTE: si usted se está tomando en serio el uso de Python, conocer estas funciones es clave para su trabajo con el lenguaje, pues le simplificará un poco más la escritura de muchas llamadas, lo que igualmente se reflejará en un código más legible. Entonces, si no conoce Python, escriba en un papel que esté a la mano, el comando dir(__builtins__). Ocasionalmente córralo, y trate de ver qué funciones de esas no usa, y trate de entenderlas y tener claro porqué no las usa. De ese modo mantendrá una visión más clara del lenguaje.
- Sistema.
Funciones que son de apoyo, como help( ), y que permite consultar información sobre cualquier, tipo, o función, y la función dir( ) que permite enumerar la lista de atributos y métodos de un objeto o clase, o globals( ) y locals( ), que enumeras los objetos que están cargados en memoria a nivel global o local a un módulo, clase, método o función, son de gran ayuda en ambientes interactivos como Python. La función vars( ) es un sinónimo de globals( ).
La función compile( ), permite compilar un código fuente de Python desde un archivo o desde la memoria, para que luego pueda ser ejecutado o evaluado por las funciones eval( ) y exec( ), también disponibles.
Tenemos también la función id( ), que permite conocer la dirección en memoria de un objeto.
- Interacción de usuario.
- Archivos.
- Tipos de datos
- Caracteres
- Representación de enteros
- Matemáticas.
- Colecciones.
- Iteradores.
- Estructura de clases.
- Formato para presentar datos.
Otros objetos y funciones están disponibles en __builtins__ , como, por ejemplo, todas las clases para tipificación de errores. Sin embargo, no se contempla describirlas.
MÓDULOS PRECARGADOS EN MEMORIA.
De otro lado, está conocer qué módulos están cargados, y, para el efecto, en el objeto builtins encontrará funciones que se pueden usar para indagarlo. Esas funciones son locals( ), globals( ) o vars( ). Por el momento, será útil usar vars( ). La función vars( ) sin pararle parámetros, permite revisar el contenido de constantes, variables, y objetos memoria, para el módulo, con sus respectivos valores:
>>> vars()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>}
>>>
__name__ es '__main__'. El valor '__main__' indica el nombre del módulo actual.
__doc__, y __package__, no contienen la información.
__loader__ contiene la referencia a un objeto relacionado con la maquinaria de carga de módulos a memoria.
Como se puede ver, solo se hay un modulo cargado, y es el de __builtins__ que ya explicamos. En la medida que cargamos nuevos módulos, quedarán registrados en memoria y aparecerán en la lista.
>>> vars()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>}
>>>
>>> import math
>>>
>>> vars()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'math': <module 'math' from '/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/lib-dynload/math.cpython-39-darwin.so'>}
>>>
Note que luego de importar la librería matemática, ya aparece registrada en la lista de objetos cargados.
De otro lado, está conocer qué módulos están cargados, y, para el efecto, en el objeto builtins encontrará funciones que se pueden usar para indagarlo. Esas funciones son locals( ), globals( ) o vars( ). Por el momento, será útil usar vars( ). La función vars( ) sin pararle parámetros, permite revisar el contenido de constantes, variables, y objetos memoria, para el módulo, con sus respectivos valores:
>>> vars()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>}
>>>
__name__ es '__main__'. El valor '__main__' indica el nombre del módulo actual.
__doc__, y __package__, no contienen la información.
__loader__ contiene la referencia a un objeto relacionado con la maquinaria de carga de módulos a memoria.
Como se puede ver, solo se hay un modulo cargado, y es el de __builtins__ que ya explicamos. En la medida que cargamos nuevos módulos, quedarán registrados en memoria y aparecerán en la lista.
>>> vars()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>}
>>>
>>> import math
>>>
>>> vars()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'math': <module 'math' from '/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/lib-dynload/math.cpython-39-darwin.so'>}
>>>
Note que luego de importar la librería matemática, ya aparece registrada en la lista de objetos cargados.
ALGUNOS CARACTERES ESPECIALES PARA PYTHON.
En Python, muchos caracteres tienen un significado especial que irá conociendo a medida que aprende a programar. Esta es una lista preliminar de usos.
PUNTO ( . ) Para decimales y para cualificar objetos.
COMA ( , ) separador de elementos de lista.
COLON ( : ) comienzo de bloque, anotaciones, valor en entrada de diccionario.
SEMICOLON ( ; ) fin de instrucción dentro de la misma línea.
SHARP ( # ) indica comentario de línea.
AT ( @ ). Decorador de función, clase, o método de clase.
DOLLAR ( $ ). Actualmente no tiene un significado especial en Python 3+.
LEFT BRACE ( { ). Para formato de cadenas.
RIGHT BRACE ( { ). Para formato de cadenas.
BACKSLASH ( \ ). Prefijo para caracter especial dentro de una string.
En Python, muchos caracteres tienen un significado especial que irá conociendo a medida que aprende a programar. Esta es una lista preliminar de usos.
PUNTO ( . ) Para decimales y para cualificar objetos.
COMA ( , ) separador de elementos de lista.
COLON ( : ) comienzo de bloque, anotaciones, valor en entrada de diccionario.
SEMICOLON ( ; ) fin de instrucción dentro de la misma línea.
SHARP ( # ) indica comentario de línea.
AT ( @ ). Decorador de función, clase, o método de clase.
DOLLAR ( $ ). Actualmente no tiene un significado especial en Python 3+.
LEFT BRACE ( { ). Para formato de cadenas.
RIGHT BRACE ( { ). Para formato de cadenas.
BACKSLASH ( \ ). Prefijo para caracter especial dentro de una string.
TIPOS DE DATOS
Como en todos los lenguajes de programación, cualquier dato está bajo la sombrilla de un tipo de dato. Python no es la excepción, y, a pesar de que en Python no hay una declaración explícita de datos, sí se da una declaración implícita que se basa en los valores que asociamos a las variables.
Otro aspecto importante de Python, es que todo valor en Python es un objeto, por lo que cada valor será el reflejo de una clase específica que contiene atributos y métodos. Los atributos son propiedades concretas de cada valor, y los métodos son funciones asociadas también a los valores.
Hagamos una enumeración de los tipos, e intentemos conocer un poco su estructura.
NOTA PARA TIPOS NUMÉRICOS. A partir de la versión 3 de Python, hay solo tres clases que permiten trabajar con objetos numéricos: int, float y complex. Antes de la versión 3 existían los tipos int y long int, con los cuales se trabajaban enteros de distinta capacidad.
Otro aspecto importante de Python, es que todo valor en Python es un objeto, por lo que cada valor será el reflejo de una clase específica que contiene atributos y métodos. Los atributos son propiedades concretas de cada valor, y los métodos son funciones asociadas también a los valores.
Hagamos una enumeración de los tipos, e intentemos conocer un poco su estructura.
NOTA PARA TIPOS NUMÉRICOS. A partir de la versión 3 de Python, hay solo tres clases que permiten trabajar con objetos numéricos: int, float y complex. Antes de la versión 3 existían los tipos int y long int, con los cuales se trabajaban enteros de distinta capacidad.
MÉTODOS ESPECIALES DE CLASE Y OBJETO
Ante de entrar a detallar de forma enumerativa los atributos y servicios de los objetos nativo de Python, veamos algunos servicios comunes en ellos.
__class__ : devuelve la clase a la que pertenece un objeto. Su uso se verá reflejado en ejemplos más adelante.
__dir__( ) : devuelve una lista de los atributos y métodos de la clase que se quiere informar. Este atributo se usa ampliamente durante esta lectura, para reconocer la funcionalidad disponible en los distintos tipos de objetos. Tenga en cuenta que no todos los métodos podrían aparecer enumerados en la lista. Este método se accede directamente desde la función dir( ) disponible en el módulo __builtins__.
__doc__( ): documenta la clase, y es desplegado como parte del trabajo de la función help( ) en el módulo __builtins__.
__sizeof__( ): devuelve el tamaño de memoria en bytes que consume el objeto, y está disponible en las tres clases int, float y complex.
__str__( ) : convierte a cadena el valor de cualquier objeto, y es invocado por el helper str( ).
Ante de entrar a detallar de forma enumerativa los atributos y servicios de los objetos nativo de Python, veamos algunos servicios comunes en ellos.
__class__ : devuelve la clase a la que pertenece un objeto. Su uso se verá reflejado en ejemplos más adelante.
__dir__( ) : devuelve una lista de los atributos y métodos de la clase que se quiere informar. Este atributo se usa ampliamente durante esta lectura, para reconocer la funcionalidad disponible en los distintos tipos de objetos. Tenga en cuenta que no todos los métodos podrían aparecer enumerados en la lista. Este método se accede directamente desde la función dir( ) disponible en el módulo __builtins__.
__doc__( ): documenta la clase, y es desplegado como parte del trabajo de la función help( ) en el módulo __builtins__.
__sizeof__( ): devuelve el tamaño de memoria en bytes que consume el objeto, y está disponible en las tres clases int, float y complex.
__str__( ) : convierte a cadena el valor de cualquier objeto, y es invocado por el helper str( ).
MÉTODOS ESPECIALES DE ATRIBUTOS DE CLASE.
Los métodos __delattr__( ), __setattr__( ), y__getattribute__( ), son usados para borrar un atributo de un objeto, establecer un valor a un atributo, y leer un valor de un atributo de un objeto. Se encuentra disponible en todos los objetos. Los objetos predefinidos de Python no permiten que sus atributos sean alterados. Estas funciones se llaman a través de las funciones delattr( ), setattr( ) y getattribute( ) de la librería __builtins__, o directamente desde el objeto.
Los métodos __delattr__( ), __setattr__( ), y__getattribute__( ), son usados para borrar un atributo de un objeto, establecer un valor a un atributo, y leer un valor de un atributo de un objeto. Se encuentra disponible en todos los objetos. Los objetos predefinidos de Python no permiten que sus atributos sean alterados. Estas funciones se llaman a través de las funciones delattr( ), setattr( ) y getattribute( ) de la librería __builtins__, o directamente desde el objeto.
ENTEROS - int
Representa números enteros positivos y negativos que pueden ser de cualquier tamaño, solo limitados por la memoria asignada al proceso Python.
>>> x = 5
>>> x.__class__
<class 'int'>
La estrategia para almacenar enteros de cualquier tamaño es interesante, dado que tradicionalmente la capacidad de una variable entera en muchos otros lenguajes de programación viene limitada por el número de bits del tipo de entero usado. Por ejemplo, en lenguajes de programación donde la máxima capacidad de un entero sea de 128 bits, el valor más grande que se podría almacenar sería de 340282366920938463463374607431768211455. Sin embargo, Python maneja una representación especial para los enteros que permite almacenar en un objeto cualquier valor entero positivo o negativo, solo limitado por la memoria disponible en el proceso Python.
Representa números enteros positivos y negativos que pueden ser de cualquier tamaño, solo limitados por la memoria asignada al proceso Python.
>>> x = 5
>>> x.__class__
<class 'int'>
La estrategia para almacenar enteros de cualquier tamaño es interesante, dado que tradicionalmente la capacidad de una variable entera en muchos otros lenguajes de programación viene limitada por el número de bits del tipo de entero usado. Por ejemplo, en lenguajes de programación donde la máxima capacidad de un entero sea de 128 bits, el valor más grande que se podría almacenar sería de 340282366920938463463374607431768211455. Sin embargo, Python maneja una representación especial para los enteros que permite almacenar en un objeto cualquier valor entero positivo o negativo, solo limitado por la memoria disponible en el proceso Python.
PUNTO FLOTANTE – float
La clase tipo float representa números reales positivos y negativos que manejan parte fraccionaria. El número más pequeño que puede ser representado es de 5e-324 (5x10-324) y el número más grande es 1.79e+308 (1.79x10308).
>>> y = 5.7
>>> y.__class__
<class 'float'>
La clase tipo float representa números reales positivos y negativos que manejan parte fraccionaria. El número más pequeño que puede ser representado es de 5e-324 (5x10-324) y el número más grande es 1.79e+308 (1.79x10308).
>>> y = 5.7
>>> y.__class__
<class 'float'>
COMPLEJOS - complex
La clase tipo complex representa números complejos, y consta de dos partes, una que representa la parte real de tipo float, y otra que representa la parte imaginaria, también de tipo float. La parte imaginaria se representa por un número seguido de la letra j o J.
>>> w = 5 + 7j
>>> w.__class__
<class 'complex'>
>>> ( w.real, w.imag)
(5.0, 7.0)
>>> w.real.__class__, w.imag.__class__)
(<class 'float'>, <class 'float'>)
Al igual que con las otras clases numéricas int y float, un objeto de tipo complex contiene funciones y atributos que definen su estado y su comportamiento.
La clase tipo complex representa números complejos, y consta de dos partes, una que representa la parte real de tipo float, y otra que representa la parte imaginaria, también de tipo float. La parte imaginaria se representa por un número seguido de la letra j o J.
>>> w = 5 + 7j
>>> w.__class__
<class 'complex'>
>>> ( w.real, w.imag)
(5.0, 7.0)
>>> w.real.__class__, w.imag.__class__)
(<class 'float'>, <class 'float'>)
Al igual que con las otras clases numéricas int y float, un objeto de tipo complex contiene funciones y atributos que definen su estado y su comportamiento.
BOOLEANOS - bool
En Python a igual que en casi todos los lenguajes de programación, existe el tipo bool, que nos permite representar los valores lógicos falso y verdadero. Existen dos valores únicos en Python: la constante False, y la constante True.
>>> b = True
>>> b.__class__
<class 'bool'>
El objeto bool en realidad es un entero, ya que la clase bool hereda directamente de la clase int.
>>> bool.__bases__
(<class 'int'>,)
Sin embargo, aunque un bool es un int, no significa que un int sea un bool.
>>> x = 9; y = True
>>> (isinstance(x,int), isinstance(x,bool))
(True, False)
>>> isinstance(y,int) , isinstance(y,bool))
(True, True)
Incluso, lo anterior significa que todas las funciones existentes para un objeto entero estarán disponibles para un objeto booleano, y se puede verificar comparando las listas de funciones y atributos de dos objetos, un entero y un booleano.
>>> dir(5) == dir(True)
True
Dado que un booleano es un entero, podremos decir que la constante True es un entero. De hecho lo es, y Python le da el valor de 1, y la constante False se reconoce como el entero cero (0). Eso significa que los dos valores booleanos pueden participar en expresiones aritméticas.
>>> t = True ; f = False
>>> 2 * t
2
>>> 3 * f
0
>>> -(True+True)*3*(True+True) - False**False
-13
>>> ( 2 * True ) ** 10
1024
En esa misma dirección, el entero cero(0) es False. Sin embargo, cualquier otro entero distinto de cero será True.
>>> (bool(0), bool(9))
(False, True)
Un número flotante también podrá ser utilizado como valor booleano. Eso es posible porque un número flotante usado como entero es truncado y convertido a entero.
>>> (int(9.8) , bool(9.8), bool(0.0), bool(-0.0))
(9, True, False, False)
En Python a igual que en casi todos los lenguajes de programación, existe el tipo bool, que nos permite representar los valores lógicos falso y verdadero. Existen dos valores únicos en Python: la constante False, y la constante True.
>>> b = True
>>> b.__class__
<class 'bool'>
El objeto bool en realidad es un entero, ya que la clase bool hereda directamente de la clase int.
>>> bool.__bases__
(<class 'int'>,)
Sin embargo, aunque un bool es un int, no significa que un int sea un bool.
>>> x = 9; y = True
>>> (isinstance(x,int), isinstance(x,bool))
(True, False)
>>> isinstance(y,int) , isinstance(y,bool))
(True, True)
Incluso, lo anterior significa que todas las funciones existentes para un objeto entero estarán disponibles para un objeto booleano, y se puede verificar comparando las listas de funciones y atributos de dos objetos, un entero y un booleano.
>>> dir(5) == dir(True)
True
Dado que un booleano es un entero, podremos decir que la constante True es un entero. De hecho lo es, y Python le da el valor de 1, y la constante False se reconoce como el entero cero (0). Eso significa que los dos valores booleanos pueden participar en expresiones aritméticas.
>>> t = True ; f = False
>>> 2 * t
2
>>> 3 * f
0
>>> -(True+True)*3*(True+True) - False**False
-13
>>> ( 2 * True ) ** 10
1024
En esa misma dirección, el entero cero(0) es False. Sin embargo, cualquier otro entero distinto de cero será True.
>>> (bool(0), bool(9))
(False, True)
Un número flotante también podrá ser utilizado como valor booleano. Eso es posible porque un número flotante usado como entero es truncado y convertido a entero.
>>> (int(9.8) , bool(9.8), bool(0.0), bool(-0.0))
(9, True, False, False)
DISECTANDO NÚMEROS int, float y complex
Un objeto entero numérico como int, float o complex, permite numerosas operaciones sobre él, como puede inferirse de la consulta previa sobre una variable de alguno de esos tipos. Muchas de sus operaciones están asociadas a operadores aritméticos, relacionales y lógicos del lenguaje, mientras que otras operaciones están asociadas a funciones disponibles en el módulo __builtins__.
Para obtener una lista de los nombres de funciones y atributos de la clase int, float, o clomplex, se puede usar la función dir(objeto).
>>> dir(int)
['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']
>>> dir(float)
['__abs__', '__add__', '__bool__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getformat__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__int__', '__le__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__pos__', '__pow__', '__radd__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rmod__', '__rmul__', '__round__', '__rpow__', '__rsub__', '__rtruediv__', '__set_format__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', 'as_integer_ratio', 'conjugate', 'fromhex', 'hex', 'imag', 'is_integer', 'real']
>>> dir(complex)
['__abs__', '__add__', '__bool__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__int__', '__le__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__pos__', '__pow__', '__radd__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rmod__', '__rmul__', '__rpow__', '__rsub__', '__rtruediv__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', 'conjugate', 'imag', 'real']
Si se disecta de una manera sistemática estas tres clases, podremos determinar empíricamente cuáles métodos son comunes, y cuales no. De esa forma, tendremos un poco más de información sobre las posibilidades con objetos de tipos int, float y complex.
Un objeto entero numérico como int, float o complex, permite numerosas operaciones sobre él, como puede inferirse de la consulta previa sobre una variable de alguno de esos tipos. Muchas de sus operaciones están asociadas a operadores aritméticos, relacionales y lógicos del lenguaje, mientras que otras operaciones están asociadas a funciones disponibles en el módulo __builtins__.
Para obtener una lista de los nombres de funciones y atributos de la clase int, float, o clomplex, se puede usar la función dir(objeto).
>>> dir(int)
['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']
>>> dir(float)
['__abs__', '__add__', '__bool__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getformat__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__int__', '__le__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__pos__', '__pow__', '__radd__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rmod__', '__rmul__', '__round__', '__rpow__', '__rsub__', '__rtruediv__', '__set_format__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', 'as_integer_ratio', 'conjugate', 'fromhex', 'hex', 'imag', 'is_integer', 'real']
>>> dir(complex)
['__abs__', '__add__', '__bool__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__int__', '__le__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__pos__', '__pow__', '__radd__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rmod__', '__rmul__', '__rpow__', '__rsub__', '__rtruediv__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', 'conjugate', 'imag', 'real']
Si se disecta de una manera sistemática estas tres clases, podremos determinar empíricamente cuáles métodos son comunes, y cuales no. De esa forma, tendremos un poco más de información sobre las posibilidades con objetos de tipos int, float y complex.
PREVISTAZO A LOS OPERADORES ARITMÉTICOS.
Disponibles en las tres clases in, float y complex, las operaciones binarias aritméticas +, -, *, /, //, %, **, se apoyan en los métodos __add__( ), __sub__( ), __mul__( ), __truediv__( ), __floordiv__( ), __mod__( ) y_pow( ).
En aquellos casos en los cuales los métodos no pueden ser aplicados al objeto de la izquierda porque no están implementados, Python aplica la función desde la derecha, usando los métodos __radd__( ), __rsub__( ), __rmul__( ), __rtruediv__( ),__rfloordiv__( ), __rmod__( ) y rpow( ).
Por ejemplo, supongamos que en la operación de los objetos cualquiera p + q, el método __radd__() no está definido para p. En ese caso, se aplica el método __radd__( ) desde el objeto de la derecha q.
Debe tener en cuenta que algunas de estas operaciones podrían no estar definidas para alguno de los tipos. Por ejemplo, la función __floordiv__( ) no se encuentra definida para números complejos, por lo que invocarla causará un error, a pesar de que se encuentran presentes en el objeto. Otro ejemplo es la función __divmod( ), la cual se encuentra disponible en las tres clases int, foat y complex, pero que no es permitida para números complejos.
Operadores unarios aritméticos.
Los operaciones unitarias aritméticas + y -, se apoyan en los métodos __pos__( ) y __neg__( ), y que devuelven el valor +x y -x para un valor de x. Se encuentran disponibles en las tres clases.
Operadores unarios aritméticos.
Los operaciones unitarias aritméticas + y -, se apoyan en los métodos __pos__( ) y __neg__( ), y que devuelven el valor +x y -x para un valor de x.
Se encuentran disponibles en las tres clases.
Funciones aritméticas.
Algunas funciones matemáticas que no cuentan con un operador explícito como los aritméticos, usan directamente las implementaciones __abs__( ), __ceil__( ) y __divmod__( ). La operación __divmod__( ) es una operación especial, ya que se apoya en las operaciones __div__( ) y
__mod__( ), y devuelve una tupla de dos valores.
Estas operaciones son llamadas directamente por funciones disponibles en la librería __builtins__ cargada por defecto por Python.
En el caso de __rdivmod__( ), la función pretende cubrir situaciones de diferencia de tipos, donde el primer operador no implementa la operación, y el segundo sí implementa la operación.
Las funciones __round__( ), __trunc__( ), no están disponibles para objetos complejos, pero sí para objetos de tipo int y float.
Las funciones __ceil__( ) y __floor__( ) se encuentran visibles para el objeto entero, y al ser invocadas directamente sobre un objeto entero, devuelven el mismo entero. Para tipos float debe incluir la librería math. Estas funciones no se encuentran definidas para tipos complex por razones teóricas.
El atributo conjugate, está solo disponible para números complejos, y se encarga de devolver la conjugada del número, esto es, la misma parte real pero cambiando el signo de la parte imaginaria.
Los atributos img y real están disponibles en todos los tipos numéricos, y como su nombre lo indica, devuelven la parte real e imaginaria de un objeto numérico.
El atributo numerator en el tipo int, siempre devuelve el número entero, mientras que el atributo denominator para un entero siempre devuelve 1.
Disponibles en las tres clases in, float y complex, las operaciones binarias aritméticas +, -, *, /, //, %, **, se apoyan en los métodos __add__( ), __sub__( ), __mul__( ), __truediv__( ), __floordiv__( ), __mod__( ) y_pow( ).
En aquellos casos en los cuales los métodos no pueden ser aplicados al objeto de la izquierda porque no están implementados, Python aplica la función desde la derecha, usando los métodos __radd__( ), __rsub__( ), __rmul__( ), __rtruediv__( ),__rfloordiv__( ), __rmod__( ) y rpow( ).
Por ejemplo, supongamos que en la operación de los objetos cualquiera p + q, el método __radd__() no está definido para p. En ese caso, se aplica el método __radd__( ) desde el objeto de la derecha q.
Debe tener en cuenta que algunas de estas operaciones podrían no estar definidas para alguno de los tipos. Por ejemplo, la función __floordiv__( ) no se encuentra definida para números complejos, por lo que invocarla causará un error, a pesar de que se encuentran presentes en el objeto. Otro ejemplo es la función __divmod( ), la cual se encuentra disponible en las tres clases int, foat y complex, pero que no es permitida para números complejos.
Operadores unarios aritméticos.
Los operaciones unitarias aritméticas + y -, se apoyan en los métodos __pos__( ) y __neg__( ), y que devuelven el valor +x y -x para un valor de x. Se encuentran disponibles en las tres clases.
Operadores unarios aritméticos.
Los operaciones unitarias aritméticas + y -, se apoyan en los métodos __pos__( ) y __neg__( ), y que devuelven el valor +x y -x para un valor de x.
Se encuentran disponibles en las tres clases.
Funciones aritméticas.
Algunas funciones matemáticas que no cuentan con un operador explícito como los aritméticos, usan directamente las implementaciones __abs__( ), __ceil__( ) y __divmod__( ). La operación __divmod__( ) es una operación especial, ya que se apoya en las operaciones __div__( ) y
__mod__( ), y devuelve una tupla de dos valores.
Estas operaciones son llamadas directamente por funciones disponibles en la librería __builtins__ cargada por defecto por Python.
En el caso de __rdivmod__( ), la función pretende cubrir situaciones de diferencia de tipos, donde el primer operador no implementa la operación, y el segundo sí implementa la operación.
Las funciones __round__( ), __trunc__( ), no están disponibles para objetos complejos, pero sí para objetos de tipo int y float.
Las funciones __ceil__( ) y __floor__( ) se encuentran visibles para el objeto entero, y al ser invocadas directamente sobre un objeto entero, devuelven el mismo entero. Para tipos float debe incluir la librería math. Estas funciones no se encuentran definidas para tipos complex por razones teóricas.
El atributo conjugate, está solo disponible para números complejos, y se encarga de devolver la conjugada del número, esto es, la misma parte real pero cambiando el signo de la parte imaginaria.
Los atributos img y real están disponibles en todos los tipos numéricos, y como su nombre lo indica, devuelven la parte real e imaginaria de un objeto numérico.
El atributo numerator en el tipo int, siempre devuelve el número entero, mientras que el atributo denominator para un entero siempre devuelve 1.
CASTING DE TIPOS.
Cuando se desea convertir un objeto a otro tipo de objeto, se pueden usar funciones constructoras de otros tipos, como __float__( ), __int__( ), __bool__( ) y __str__( ). Esto es equivalente a un constructor directo float( ), int( ), bool( ) o str( ) respectivamente.
>>> x = 100
>>> x.__float__()
100.0
>>> x.__bool__()
True
>>> x.__str__()
'100'
>>> float(x)
100.0
>>> bool(x)
True
>>> str(x)
'100'
Estas operaciones devuelven un objeto de tipo float, int, bool y str respectivamente, como era de esperarse. Debe tenerse en cuenta que, no todas las operaciones de cating son posibles sobre todos los tipos. Por ejemplo, no es posible con el métodos __float__ convertir un objeto real a complejo.
Las operación __int__( ) no está disponible para el tipo de dato complejo.
Cuando se desea convertir un objeto a otro tipo de objeto, se pueden usar funciones constructoras de otros tipos, como __float__( ), __int__( ), __bool__( ) y __str__( ). Esto es equivalente a un constructor directo float( ), int( ), bool( ) o str( ) respectivamente.
>>> x = 100
>>> x.__float__()
100.0
>>> x.__bool__()
True
>>> x.__str__()
'100'
>>> float(x)
100.0
>>> bool(x)
True
>>> str(x)
'100'
Estas operaciones devuelven un objeto de tipo float, int, bool y str respectivamente, como era de esperarse. Debe tenerse en cuenta que, no todas las operaciones de cating son posibles sobre todos los tipos. Por ejemplo, no es posible con el métodos __float__ convertir un objeto real a complejo.
Las operación __int__( ) no está disponible para el tipo de dato complejo.
OPERACIONES SOBRE BITS.
Las operaciones lógicas y de desplazamiento a nivel de bits solo aplican a números enteros, y corresponden a los operadores & , | , ^ , >> y << , y se apoyan en los métodos de objeto
__or__( ), __and__( ), __xor__( ), __rshift__( ) y __lshift__( ). Estas operaciones no son permitidas para objetos reales y complejos.
En aquellos casos en los cuales los métodos no pueden ser aplicados al objeto de la izquierda porque no están implementados, Python aplica la función desde la derecha, usando los métodos __ror__( ), __rand__( ),__rxor__( ), __rlshift__( ) y __rrshift__( ).
Por ejemplo, si la operación x and y no está definida para x, se aplica el método __rand__( ) desde el objeto de la derecha.
El método bit_length( ), devuelve el número de bits necesarios para representar el número dado. Este método no está disponible sino para la clase int.
Las operaciones lógicas y de desplazamiento a nivel de bits solo aplican a números enteros, y corresponden a los operadores & , | , ^ , >> y << , y se apoyan en los métodos de objeto
__or__( ), __and__( ), __xor__( ), __rshift__( ) y __lshift__( ). Estas operaciones no son permitidas para objetos reales y complejos.
En aquellos casos en los cuales los métodos no pueden ser aplicados al objeto de la izquierda porque no están implementados, Python aplica la función desde la derecha, usando los métodos __ror__( ), __rand__( ),__rxor__( ), __rlshift__( ) y __rrshift__( ).
Por ejemplo, si la operación x and y no está definida para x, se aplica el método __rand__( ) desde el objeto de la derecha.
El método bit_length( ), devuelve el número de bits necesarios para representar el número dado. Este método no está disponible sino para la clase int.
OPERADORES RELACIONALES.
Las operaciones relacionales usadas en condicionales, >=, >, <=, <, ==, !=, se apoyan en las funciones __ge__( ), __gt__( ), __le__( ), __lt__( ), __eq__( ) y__ne__( ).
Están disponibles en todos los objetos numéricos, int, float y complex.
Las operaciones relacionales usadas en condicionales, >=, >, <=, <, ==, !=, se apoyan en las funciones __ge__( ), __gt__( ), __le__( ), __lt__( ), __eq__( ) y__ne__( ).
Están disponibles en todos los objetos numéricos, int, float y complex.
STRINGS - str
En Python podemos trabajar conjuntos de caracteres. Estos caracteres representan información legible y cada caracter tiene un código decimal que lo identifica internamente. Para escribir una cadena, la delimitamos con dobles comillas, o comillas simples. El primer caracter se define que está en la posición 0, el segundo en la 1, y así sucesivamente. Al conjunto de estos caracteres se le denomina strings en los lenguajes de programación.
En Python, este tipo lo maneja la clase str.
>>> x="我爱你" #"te amo, escrito en chino simplificado
>>> x.__class__
<class 'str'>
Cada uno de los caracteres de una cadena o un conjunto de ellos, puede ser accedido usando los símbolos corchete izquierdo y corchete derecho. ([ ]).
>>> x=’ABC’
>>> x.__class__
<class 'str'>
>>> x[0]
'A'
Python no cuenta con el tipo de dato caracter, como sí sucede con muchos otros lenguajes.
Por tal motivo, un solo caracter lo trata como una cadena de caracteres.
>>> x[0].__class__
<class 'str'>
>>> ‘A’
En Python, este tipo lo maneja la clase str.
>>> x="我爱你" #"te amo, escrito en chino simplificado
>>> x.__class__
<class 'str'>
Cada uno de los caracteres de una cadena o un conjunto de ellos, puede ser accedido usando los símbolos corchete izquierdo y corchete derecho. ([ ]).
>>> x=’ABC’
>>> x.__class__
<class 'str'>
>>> x[0]
'A'
Python no cuenta con el tipo de dato caracter, como sí sucede con muchos otros lenguajes.
Por tal motivo, un solo caracter lo trata como una cadena de caracteres.
>>> x[0].__class__
<class 'str'>
>>> ‘A’
DISECTANDO LA CLASE str
Una string en Python es un objeto basado en una clase con una amplia posibilidad de funciones y atributos. Uno de los aspectos más interesantes en programación cuando las personas están haciendo desarrollo, es que muchas de las cosas que necesitan hacer en Python con cadenas, no las conocen porque no han indagado antes las posibilidades con el objeto cadena.
En ambientes de desarrollo es más simple, pues cuentan con la tecnología intellisense que les permite conocer los métodos y atributos de un objeto a medida que escriben código.
En editores de texto sin esta característica, o cuando se trabaja en consola, una consulta como dir(str) puede ser un gran salvavidas. A medida que se aprende el lenguaje ya será más fácil recordarlos.
>>> dir(str)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
A continuación, hagamos un recorrido somero, para ver qué potencial tenemos.
Operaciones relacionales.
Al igual que cualquier otro objeto en Python, una cadena de caracteres puede ser operada con operadores relacionales.
Las operaciones relacionales usadas en condicionales, >=, >, <=, <, ==, !=, se apoyan en las funciones __ge__( ), __gt__( ), __le__( ), __lt__( ), __eq__( ) y__ne__( ).
Operadores aritméticos aplicados a strings.
las operaciones binarias aritméticas +, * y % se apoyan en los métodos __add__( ), __mul__( ) y __mod__( ), y tienen significado al ser usados con cadenas. Con + podemos concatener cadenas, con * podemos construir una nueva cadena repetida n veces, y con % podemos formatear cadenas.
También están disponibles las operaciones __rmul__( ) y __rmod__( ) para inversiones de los operandos en un expresión.
Obtención de información de strings.
La función __len( )__ devuelve la longitud de una cadena en caracteres.
Las siguientes funciones isalnum( ), isalpha( ), isascii( ), isdecimal( ), isdigit( ), islower( ), isnumeric( ), isprintable( ), isspace( ), istitle( ), isupper( ), startswith( ), endswith( ), count ( ), find( ) e index( ), rfind( ) y rindex( ), y __contains__( ), chequean varias características de la cadena o de su contenido, a saber, si combina números y letras, si solo contiene letras, si el caracter está en la tabla ascii, si representa un número decimal, si contiene solo dígitos, si contiene solo minúsculas, si es un dato numérico, si es imprimible, esto es, si ocupa espacio al momento de presentar texto, si representa espacios, si es un título (cada palabra en la string contiene como primer caracter una letra mayúscula), si la cadena la componen caracteres solo mayúscula, si comienza con una substring específica, si finaliza con una substring particular, contar cuántas veces está una substring concreta dentro de la cadena, determinar la primera posición desde la izquierda en que aparece una substring, determinar la primera posición desde la derecha en que aparece una substring y determinar si una cadena específica está en cualquier lugar dentro de una cadena.
Esta sección del texto no es un manual de referencia del lenguaje, donde se describe cada método, y por tal motivo no se enumera detalladamente la estructura de cada uno de ellos.
Existe una función especial llamada isidentifier( ), que devuelve True si la string es un identificador válido. Una cadena se considera un identificador válido si su contenido es una combinación de letras y números(0-9), o simplemente letras, pudiendo incluir el caracter ‘_’ (underscore) entre ellos. Si la combinación es de letras y dígitos, debe comenzar con una letra.
Conversiones.
Las funciones capitalize( ), lower( ), upper( ), strip( ), lstrip( ), rstrip( ), ljust( ),
rjust( ), swapcase( ), zfill( ), center( ), replace( ), casefold( ), expandtabs( ).
Transformaciones.
Las funciones split( ), splitlines( ), partition( ), rpartition( ), permiten particionar la cadena desde diferentes ópticas, algo que es muy práctico desde la experiencia en programación del autor en otros lenguajes.
La función join( ) aplicada a una cadena, permite tomar una colección de cadenas, y las unifica poniendo la cadena sobre la que se invocó la función en el medio de todas las cadenas iteradas.
Una string en Python es un objeto basado en una clase con una amplia posibilidad de funciones y atributos. Uno de los aspectos más interesantes en programación cuando las personas están haciendo desarrollo, es que muchas de las cosas que necesitan hacer en Python con cadenas, no las conocen porque no han indagado antes las posibilidades con el objeto cadena.
En ambientes de desarrollo es más simple, pues cuentan con la tecnología intellisense que les permite conocer los métodos y atributos de un objeto a medida que escriben código.
En editores de texto sin esta característica, o cuando se trabaja en consola, una consulta como dir(str) puede ser un gran salvavidas. A medida que se aprende el lenguaje ya será más fácil recordarlos.
>>> dir(str)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
A continuación, hagamos un recorrido somero, para ver qué potencial tenemos.
Operaciones relacionales.
Al igual que cualquier otro objeto en Python, una cadena de caracteres puede ser operada con operadores relacionales.
Las operaciones relacionales usadas en condicionales, >=, >, <=, <, ==, !=, se apoyan en las funciones __ge__( ), __gt__( ), __le__( ), __lt__( ), __eq__( ) y__ne__( ).
Operadores aritméticos aplicados a strings.
las operaciones binarias aritméticas +, * y % se apoyan en los métodos __add__( ), __mul__( ) y __mod__( ), y tienen significado al ser usados con cadenas. Con + podemos concatener cadenas, con * podemos construir una nueva cadena repetida n veces, y con % podemos formatear cadenas.
También están disponibles las operaciones __rmul__( ) y __rmod__( ) para inversiones de los operandos en un expresión.
Obtención de información de strings.
La función __len( )__ devuelve la longitud de una cadena en caracteres.
Las siguientes funciones isalnum( ), isalpha( ), isascii( ), isdecimal( ), isdigit( ), islower( ), isnumeric( ), isprintable( ), isspace( ), istitle( ), isupper( ), startswith( ), endswith( ), count ( ), find( ) e index( ), rfind( ) y rindex( ), y __contains__( ), chequean varias características de la cadena o de su contenido, a saber, si combina números y letras, si solo contiene letras, si el caracter está en la tabla ascii, si representa un número decimal, si contiene solo dígitos, si contiene solo minúsculas, si es un dato numérico, si es imprimible, esto es, si ocupa espacio al momento de presentar texto, si representa espacios, si es un título (cada palabra en la string contiene como primer caracter una letra mayúscula), si la cadena la componen caracteres solo mayúscula, si comienza con una substring específica, si finaliza con una substring particular, contar cuántas veces está una substring concreta dentro de la cadena, determinar la primera posición desde la izquierda en que aparece una substring, determinar la primera posición desde la derecha en que aparece una substring y determinar si una cadena específica está en cualquier lugar dentro de una cadena.
Esta sección del texto no es un manual de referencia del lenguaje, donde se describe cada método, y por tal motivo no se enumera detalladamente la estructura de cada uno de ellos.
Existe una función especial llamada isidentifier( ), que devuelve True si la string es un identificador válido. Una cadena se considera un identificador válido si su contenido es una combinación de letras y números(0-9), o simplemente letras, pudiendo incluir el caracter ‘_’ (underscore) entre ellos. Si la combinación es de letras y dígitos, debe comenzar con una letra.
Conversiones.
Las funciones capitalize( ), lower( ), upper( ), strip( ), lstrip( ), rstrip( ), ljust( ),
rjust( ), swapcase( ), zfill( ), center( ), replace( ), casefold( ), expandtabs( ).
Transformaciones.
Las funciones split( ), splitlines( ), partition( ), rpartition( ), permiten particionar la cadena desde diferentes ópticas, algo que es muy práctico desde la experiencia en programación del autor en otros lenguajes.
La función join( ) aplicada a una cadena, permite tomar una colección de cadenas, y las unifica poniendo la cadena sobre la que se invocó la función en el medio de todas las cadenas iteradas.
ITERADORES SOBRE STRINGS.
El método __iter__, y que es invocado por la función iter( ) del módulo __builtins__), permite crear un objeto iterador de cadena, que habilita recorrer la cadena con un bucle iterador for como veremos más adelante.
El método __iter__, y que es invocado por la función iter( ) del módulo __builtins__), permite crear un objeto iterador de cadena, que habilita recorrer la cadena con un bucle iterador for como veremos más adelante.
OBTENER ELEMENTOS ESPECIFICOS.
Para obtener elementos específicos de una cadena, se puede usar el operador de indexación ([ ]), al que se le especifica una posición usando un objeto int, o un rango de posiciones usando un objeto slice.
También se puede usar el método __getitem__( ) para acceder a los elementos de una cadena: cada que se usa el operador [], se invoca el método __getitem__( ).
El método __getitem__( ), entonces, recibe como parámetro un valor entero para acceder a un caracter, o un objeto slice con la información del rango de valores que se desea extraer.
Para obtener elementos específicos de una cadena, se puede usar el operador de indexación ([ ]), al que se le especifica una posición usando un objeto int, o un rango de posiciones usando un objeto slice.
También se puede usar el método __getitem__( ) para acceder a los elementos de una cadena: cada que se usa el operador [], se invoca el método __getitem__( ).
El método __getitem__( ), entonces, recibe como parámetro un valor entero para acceder a un caracter, o un objeto slice con la información del rango de valores que se desea extraer.
LISTAS - list
En Python, para agrupar un conjunto de valores de cualquier tipo y que sean mutables (luego de definida la lista sus elementos pueden ser modificados), usamos una estructura que se denomina list.
Entonces, una lista es un objeto que me representa un conjunto de valores, o sequencia de valores, que pueden ser de distinto tipo; esto es, en alguna de las posiciones de una lista podemos almacenar cualquier tipo de objeto, como int, float, complex, bool, listas, o otros objetos.
Para acceder un elemento de una lista, usamos corchetes([]), o el método getitem().
Para crear una lista, se usan corchetes [ ], y dentro de los corchetes, los elementos separados por coma(,). Puede dejar una coma al final si lo desea y sin efecto colateral(Bader, 2017), característica que posiblemente existe para evitar errores posteriores si se quiere adicionar un nuevo elemento.
Tenga también en cuenta que la primera posición de la lista siempre se indexa con cero[1].
>>> l = [ True, "@ character", ord('@'), [1,2,3] , ]
>>> type(l)
<class 'list'>
>>> ( l[0].__class__, l[1].__class__, l[2].__class__, l[3].__class__)
(<class 'bool'>, <class 'str'>, <class 'int'>, <class 'list'>)
Dado que la lista es mutable, los elementos pueden ser alterados, e incluso borrados.
>>> l = [True, 'W', 64, False]
>>> l[3] = True
>>> l
[True, 'W', 64, True]
>>> l.__getitem__(1)
'W'
[1] En muchos lenguajes de programación la primera posición de estructuras similares a la lista es también cero. Esto no es una regla, y hay lenguajes cuya primera posición es 1.
Entonces, una lista es un objeto que me representa un conjunto de valores, o sequencia de valores, que pueden ser de distinto tipo; esto es, en alguna de las posiciones de una lista podemos almacenar cualquier tipo de objeto, como int, float, complex, bool, listas, o otros objetos.
Para acceder un elemento de una lista, usamos corchetes([]), o el método getitem().
Para crear una lista, se usan corchetes [ ], y dentro de los corchetes, los elementos separados por coma(,). Puede dejar una coma al final si lo desea y sin efecto colateral(Bader, 2017), característica que posiblemente existe para evitar errores posteriores si se quiere adicionar un nuevo elemento.
Tenga también en cuenta que la primera posición de la lista siempre se indexa con cero[1].
>>> l = [ True, "@ character", ord('@'), [1,2,3] , ]
>>> type(l)
<class 'list'>
>>> ( l[0].__class__, l[1].__class__, l[2].__class__, l[3].__class__)
(<class 'bool'>, <class 'str'>, <class 'int'>, <class 'list'>)
Dado que la lista es mutable, los elementos pueden ser alterados, e incluso borrados.
>>> l = [True, 'W', 64, False]
>>> l[3] = True
>>> l
[True, 'W', 64, True]
>>> l.__getitem__(1)
'W'
[1] En muchos lenguajes de programación la primera posición de estructuras similares a la lista es también cero. Esto no es una regla, y hay lenguajes cuya primera posición es 1.
DISECTANDO LA CLASE list.
Las listas son potencialmente la estructura más empleada en Python para resolver muchos tipos de problemas, por lo que es ideal entenderla un poco. Los métodos y atributos de la clase list pueden ser presentadas usando la función dir(). A través de esta estructura de clase, podremos entender mejor qué podemos hacer sobre una lista de forma nativa en Python.
>>> dir(list)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
Operaciones relacionales: comparar listas elemento a elemento.
Como en otros objetos, una lista d puede ser operada con operadores relacionales.
Las operaciones relacionales disponible para una lista son , ==, >=, >, <=, <, !=, se apoyan en las funciones __eq__( ), __ge__( ), __gt__( ), __le__( ), __lt__( ), y __ne__( ). Esto significa que podemos hacer comparaciones entre listas. Pero en este caso, hay que entender cómo funcionan dichas comparaciones. La idea es comparar elemento a elemento, siempre y cuando sean comparables los tipos. Si la comparación posición a posición se cumple para todos los elementos, es verdadera. De lo contrario, es falsa. La comparación se da solo hasta el tamaño de la menor cadena.
>>> [0,"2",100,200,300,400] < [1,"3"]
True
En este ejemplo, la cadena de la izquierda es menor a la cadena de la derecha. Eso se debe a que solo se comparan los elementos que sea posible comparar. Por lo tanto, lo anterior equivale a:
0 < 1 and "2" < "3", lo que es cierto. Note que los tipos de las posiciones que se comparen deben ser compatibles para comparación. De lo contrario saldrá un error.
Adición de elementos a la lista.
Permiten agregar elementos a la lista. Se sobrecargan los operadores += y *=. Las funciones que se recargan son __iadd__( ) e __imult__( ) respectivamente.
La operación += adiciona al final de la lista los elementos que estén en la nueva lista.
>>> x=[1,2,3,4,5]
>>> x += [6,7,8,9] #adicionar 4 nuevos elementos al final
>>> x
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> x.__iadd__([11,12,13,14,15]) #adicionar otros 4 elementos al final
[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15]
La operación *= recibe un número, y repite la lista tantas veces como el número indique para obtener la nueva lista, y altera la lista original.
>>> [1,2,3]*25
[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
El método append( ) adiciona un elemento al final de la lista.
El métodos extend( ) adiciona elementos desde un iterable, por ejemplo otra lista, desde la cual extraerá los elementos que adicionará al final.
El métodos insert( ) adiciona un elemento en una posición específica.
Borrado de elementos de la lista.
El método pop( ), por su lado, borra el último elemento de la lista.
El método remove( ), borra la primera ocurrencia de un elemento específico.
El método clear( ), borra todos los elementos de la lista.
El método __delitem__( ), borra un elemento dada su posición.
Búsquedas de elementos en la lista.
El método __getitem__( ), obtiene el valor de una posición de la lista, a través de la sobrecarga del operador [ ]. Dado que el operador puede obtener un entero o un slice, el método podrá también obtener un entero o un slice.
El método count( ) determina cuántas veces se encuentra un elemento concreto en la lista.
El método index( ), determina la posición de la primera ocurrencia de un elemento. Se le puede especificar un rango de índices de búsqueda.
Operaciones sobre la lista entera.
El método __len__( ), es invocado por la función len( ) de __builtins__, y devuelve el número de elementos de la lista.
El método __mult__( ) recibe un número, y repite la lista tantas veces como el número indique para obtener la nueva lista, y devuelve el resultado sin alterar la lista original. El método __rmult__( ), existe para garantizar que se pueda hacer la operación invirtiendo los operandos.
El método __reversed__( ), devuelve un iterador que permite navegar los elementos de la lista uno a uno, de atrás hacia adelante.
El método reverse( ) invierte los elementos de la lista.
El método copy( ) obtiene una nueva lista que es una copia de la original..
El método __str__( ), lo invoca la función str( ) de __builtins__, y convierte toda la lista a una cadena. La cadena aparece ahora como una string.
>>> x=[89,78,12,1,90]
>>> str(x)
'[89, 78, 12, 1, 90]'
Todavía hay unos pocos métodos y atributos que no discutiremos en esta disección.
Las listas son potencialmente la estructura más empleada en Python para resolver muchos tipos de problemas, por lo que es ideal entenderla un poco. Los métodos y atributos de la clase list pueden ser presentadas usando la función dir(). A través de esta estructura de clase, podremos entender mejor qué podemos hacer sobre una lista de forma nativa en Python.
>>> dir(list)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
Operaciones relacionales: comparar listas elemento a elemento.
Como en otros objetos, una lista d puede ser operada con operadores relacionales.
Las operaciones relacionales disponible para una lista son , ==, >=, >, <=, <, !=, se apoyan en las funciones __eq__( ), __ge__( ), __gt__( ), __le__( ), __lt__( ), y __ne__( ). Esto significa que podemos hacer comparaciones entre listas. Pero en este caso, hay que entender cómo funcionan dichas comparaciones. La idea es comparar elemento a elemento, siempre y cuando sean comparables los tipos. Si la comparación posición a posición se cumple para todos los elementos, es verdadera. De lo contrario, es falsa. La comparación se da solo hasta el tamaño de la menor cadena.
>>> [0,"2",100,200,300,400] < [1,"3"]
True
En este ejemplo, la cadena de la izquierda es menor a la cadena de la derecha. Eso se debe a que solo se comparan los elementos que sea posible comparar. Por lo tanto, lo anterior equivale a:
0 < 1 and "2" < "3", lo que es cierto. Note que los tipos de las posiciones que se comparen deben ser compatibles para comparación. De lo contrario saldrá un error.
Adición de elementos a la lista.
Permiten agregar elementos a la lista. Se sobrecargan los operadores += y *=. Las funciones que se recargan son __iadd__( ) e __imult__( ) respectivamente.
La operación += adiciona al final de la lista los elementos que estén en la nueva lista.
>>> x=[1,2,3,4,5]
>>> x += [6,7,8,9] #adicionar 4 nuevos elementos al final
>>> x
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> x.__iadd__([11,12,13,14,15]) #adicionar otros 4 elementos al final
[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15]
La operación *= recibe un número, y repite la lista tantas veces como el número indique para obtener la nueva lista, y altera la lista original.
>>> [1,2,3]*25
[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
El método append( ) adiciona un elemento al final de la lista.
El métodos extend( ) adiciona elementos desde un iterable, por ejemplo otra lista, desde la cual extraerá los elementos que adicionará al final.
El métodos insert( ) adiciona un elemento en una posición específica.
Borrado de elementos de la lista.
El método pop( ), por su lado, borra el último elemento de la lista.
El método remove( ), borra la primera ocurrencia de un elemento específico.
El método clear( ), borra todos los elementos de la lista.
El método __delitem__( ), borra un elemento dada su posición.
Búsquedas de elementos en la lista.
El método __getitem__( ), obtiene el valor de una posición de la lista, a través de la sobrecarga del operador [ ]. Dado que el operador puede obtener un entero o un slice, el método podrá también obtener un entero o un slice.
El método count( ) determina cuántas veces se encuentra un elemento concreto en la lista.
El método index( ), determina la posición de la primera ocurrencia de un elemento. Se le puede especificar un rango de índices de búsqueda.
Operaciones sobre la lista entera.
El método __len__( ), es invocado por la función len( ) de __builtins__, y devuelve el número de elementos de la lista.
El método __mult__( ) recibe un número, y repite la lista tantas veces como el número indique para obtener la nueva lista, y devuelve el resultado sin alterar la lista original. El método __rmult__( ), existe para garantizar que se pueda hacer la operación invirtiendo los operandos.
El método __reversed__( ), devuelve un iterador que permite navegar los elementos de la lista uno a uno, de atrás hacia adelante.
El método reverse( ) invierte los elementos de la lista.
El método copy( ) obtiene una nueva lista que es una copia de la original..
El método __str__( ), lo invoca la función str( ) de __builtins__, y convierte toda la lista a una cadena. La cadena aparece ahora como una string.
>>> x=[89,78,12,1,90]
>>> str(x)
'[89, 78, 12, 1, 90]'
Todavía hay unos pocos métodos y atributos que no discutiremos en esta disección.
TUPLAS - tuple
En Python, una tupla es una lista inmutable, esto es, luego de que la tupla ha sido creada, sus valores no pueden ser modificados. Se instancia con el uso de la clase tuple. La tupla se encierra entre paréntesis al momento de ser creada explícitamente.
Debido a que es inmutable, no se pueden alterar sus elementos como se hace con una lista, y el intento de hacerlo va a mostrar un error, indicando que el objeto tipo tupla no tiene definida esa operación. La forma de acceder sus elementos es la misma que con un objeto tipo list.
>>> t = ( True, "X", ord('@'), [1,2,3])
>>> type(t)
<class 'tuple'>
>>> ( t[3], t[0], t[2], t[1])
([1, 2, 3], True, 64, 'X')
Ya dijimos que la tupla es una lista inmutable. Por tal motivo, podemos usar también los corchetes para acceder sus elementos, así como también su método __getitem__( ).
>>> t.__getitem__(1)
'X'
>>>
Debido a que es inmutable, no se pueden alterar sus elementos como se hace con una lista, y el intento de hacerlo va a mostrar un error, indicando que el objeto tipo tupla no tiene definida esa operación. La forma de acceder sus elementos es la misma que con un objeto tipo list.
>>> t = ( True, "X", ord('@'), [1,2,3])
>>> type(t)
<class 'tuple'>
>>> ( t[3], t[0], t[2], t[1])
([1, 2, 3], True, 64, 'X')
Ya dijimos que la tupla es una lista inmutable. Por tal motivo, podemos usar también los corchetes para acceder sus elementos, así como también su método __getitem__( ).
>>> t.__getitem__(1)
'X'
>>>
DISECTANDO LA CLASE tuple.
Los métodos y atributos de la clase tuple pueden ser presentados usando la función dir().
>>> dir(tuple)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
Dado que la tupla puede ser vista como una lista que no puede ser modificada (inmutabilidad), los demás métodos son comparables, y podemos referirnos a ellos como se explicó en la disección de una lista.
Los métodos y atributos de la clase tuple pueden ser presentados usando la función dir().
>>> dir(tuple)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
Dado que la tupla puede ser vista como una lista que no puede ser modificada (inmutabilidad), los demás métodos son comparables, y podemos referirnos a ellos como se explicó en la disección de una lista.
'MAPPING' EN Python - dict
En Python, un conjunto de valores, donde cada valor puede ser accedido a través de una clave, se le conoce como diccionario. Los diccionarios son estructuras mutables donde los elementos no se acceden por posición, sino por clave.
Un valor puede ser cualquier tipo de objeto, como int, float, complex, bool, string, listas, otros diccionarios, o cualquier otro objeto por complejo que sea. Sin embargo, la clave de una posición solo puede ser de tipo bool, int, float, o str.
Cuando el diccionario se expresa entre llaves con sus elementos, la clave siempre se representa a la izquierda y el valor a la derecha, ambos separados por el caracter dos puntos ( ':' ).
>>> k={'A':'letra A'}
>>> k[2]=-5 #adicionar nuevo elemento con una nueva clave
>>> k
{'A': 'letra A', 2: -5}
Si se usa una clave tipo bool, se debe tener presente que la clave True equivale a la clave 1, y la clave False equivale a la clave 0.
>>> {True:'A', 1:'B', 1.0:'C'}
{True: 'C'}
El anterior resultado se debe a que, para Python, los valores True, 1 y 1.0 son el mismo. Por tal motivo, la segunda y tercera entrada encuentran la existencia de la primera clave, generándose así el curioso resultado que se muestra, donde no se puede crerar el diciconario con 3 entradas, sino sólo una.
Un valor puede ser cualquier tipo de objeto, como int, float, complex, bool, string, listas, otros diccionarios, o cualquier otro objeto por complejo que sea. Sin embargo, la clave de una posición solo puede ser de tipo bool, int, float, o str.
Cuando el diccionario se expresa entre llaves con sus elementos, la clave siempre se representa a la izquierda y el valor a la derecha, ambos separados por el caracter dos puntos ( ':' ).
>>> k={'A':'letra A'}
>>> k[2]=-5 #adicionar nuevo elemento con una nueva clave
>>> k
{'A': 'letra A', 2: -5}
Si se usa una clave tipo bool, se debe tener presente que la clave True equivale a la clave 1, y la clave False equivale a la clave 0.
>>> {True:'A', 1:'B', 1.0:'C'}
{True: 'C'}
El anterior resultado se debe a que, para Python, los valores True, 1 y 1.0 son el mismo. Por tal motivo, la segunda y tercera entrada encuentran la existencia de la primera clave, generándose así el curioso resultado que se muestra, donde no se puede crerar el diciconario con 3 entradas, sino sólo una.
DISECTANDO LA CLASE dict
Es interesante revisar la estructura de un diccionario con el comando dir().
>>> dir(dict)
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
El diccionario es, una de las estructuras de datos más poderosas de Python, ya que gran cantidad de aspectos del lenguaje se encuentran implementados con él.
Una de las características más interesantes de un diccionario en Python, es que es directamente una estructura Json, estructura muy popular para representar y transferir información en la web. Es por eso por lo que, al usar cualquier estructura json que tenga claves en sus entradas, automáticamente para Python es un diccionario.
Algunos servicios se presentan.
el método __setiterm__( ) establece un elemento a un valor. Si no existe, lo crea. Equivale a trabajar con el operador []. Prefiera trabajar con el operador [].
>>> d = {True:'A', 2:'B', 3:'C'}
>>> d.__setitem__('S',0)
>>> d
{True: 'A', 2: 'B', 3: 'C', 'S': 0}
>>> d['T'] = 1
>>> d
{True: 'A', 2: 'B', 3: 'C', 'S': 0, 'T': 1}
>>>
el método items() devuelve una lista con tuplas, cada tupla representando cada elemento:
>>> d.items()
dict_items([(True, 'A'), (2, 'B'), (3, 'C')])
>>>
los métodos keys( ) y values( ), devuelven listas de claves y de valores respectivamente:
>>> d.keys()
dict_keys([True, 2, 3])
>>> d.values()
dict_values(['A', 'B', 'C'])
>>>
el método pop( ), elimina un elemento del diccionario a partir de su clave, y devuelve la clave borrada:
>>> d.pop(True)
'A'
>>> d
{2: 'B', 3: 'C'}
el método popitem(), elimina el último elemento que haya sido ingresado al diccionario, y devuelve una tupla (clave, valor).
>>> d.popitem()
(3, 'C')
el método clear( ) borra el contenido del diccionario:
>>> d.clear()
>>> d
{}
>>>
Es interesante revisar la estructura de un diccionario con el comando dir().
>>> dir(dict)
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
El diccionario es, una de las estructuras de datos más poderosas de Python, ya que gran cantidad de aspectos del lenguaje se encuentran implementados con él.
Una de las características más interesantes de un diccionario en Python, es que es directamente una estructura Json, estructura muy popular para representar y transferir información en la web. Es por eso por lo que, al usar cualquier estructura json que tenga claves en sus entradas, automáticamente para Python es un diccionario.
Algunos servicios se presentan.
el método __setiterm__( ) establece un elemento a un valor. Si no existe, lo crea. Equivale a trabajar con el operador []. Prefiera trabajar con el operador [].
>>> d = {True:'A', 2:'B', 3:'C'}
>>> d.__setitem__('S',0)
>>> d
{True: 'A', 2: 'B', 3: 'C', 'S': 0}
>>> d['T'] = 1
>>> d
{True: 'A', 2: 'B', 3: 'C', 'S': 0, 'T': 1}
>>>
el método items() devuelve una lista con tuplas, cada tupla representando cada elemento:
>>> d.items()
dict_items([(True, 'A'), (2, 'B'), (3, 'C')])
>>>
los métodos keys( ) y values( ), devuelven listas de claves y de valores respectivamente:
>>> d.keys()
dict_keys([True, 2, 3])
>>> d.values()
dict_values(['A', 'B', 'C'])
>>>
el método pop( ), elimina un elemento del diccionario a partir de su clave, y devuelve la clave borrada:
>>> d.pop(True)
'A'
>>> d
{2: 'B', 3: 'C'}
el método popitem(), elimina el último elemento que haya sido ingresado al diccionario, y devuelve una tupla (clave, valor).
>>> d.popitem()
(3, 'C')
el método clear( ) borra el contenido del diccionario:
>>> d.clear()
>>> d
{}
>>>
CONJUNTOS - set
En Python existe un tipo de dato que nos permite contener valores únicos. Esto es, si se adicionan dos valores iguales, solo una versión del valor queda almacenada en el conjunto. Es el mismo concepto de conjunto que nos enseñan en las escuelas. Existen operaciones entre conjuntos, como unión, intersección, diferencia, etc.
En un conjunto Python se puede almacenar cualquier tipo de valor, siempre y cuando no sea mutable. Una lista no puede ser almacenada porque es mutable. Pero una tupla sí puede ser almacenada dada su naturaleza inmutable.
>>> s=set()
>>> type(s)
<class 'set'>
>>> s.add(1) ; s.add(2) ; s.add(3)
>>> s.add('hello')
>>> s.add(3.14159)
>>> s.add((3.1, 2.2))
>>> s
{(3.1, 2.2), 1, 2, 3, 3.14159, 'hello'}
>>>
Acceso a elementos de un set
Un elemento de un ‘set’ no puede ser accedido como se hace en el caso de un diccionario. Sin embargo, se puede averiguar si un elemento se encuentra en el conjunto, se puede retirar un elemento con solo mencionar su valor, o se puede retirar un elemento de forma aleatoria.
Aparte de eso, se pueden llevar a cabo muchas operaciones sobre conjuntos, como unión, diferencia, intersección, etc., como se puede ver arriba de la lista de métodos del objeto.
>>> t=set()
>>> t.add(1)
>>> t.add(7)
>>> t.add('hello')
>>> t
{'hello', 1, 7}
>>> s.union(t)
{1.1, 1, (8+9j), 4, 7, 'hello', 'a', 'abc', 'c', 'b'}
>>> len(s),len(t), len(s.union(t))
(8, 3, 10)
En un conjunto Python se puede almacenar cualquier tipo de valor, siempre y cuando no sea mutable. Una lista no puede ser almacenada porque es mutable. Pero una tupla sí puede ser almacenada dada su naturaleza inmutable.
>>> s=set()
>>> type(s)
<class 'set'>
>>> s.add(1) ; s.add(2) ; s.add(3)
>>> s.add('hello')
>>> s.add(3.14159)
>>> s.add((3.1, 2.2))
>>> s
{(3.1, 2.2), 1, 2, 3, 3.14159, 'hello'}
>>>
Acceso a elementos de un set
Un elemento de un ‘set’ no puede ser accedido como se hace en el caso de un diccionario. Sin embargo, se puede averiguar si un elemento se encuentra en el conjunto, se puede retirar un elemento con solo mencionar su valor, o se puede retirar un elemento de forma aleatoria.
Aparte de eso, se pueden llevar a cabo muchas operaciones sobre conjuntos, como unión, diferencia, intersección, etc., como se puede ver arriba de la lista de métodos del objeto.
>>> t=set()
>>> t.add(1)
>>> t.add(7)
>>> t.add('hello')
>>> t
{'hello', 1, 7}
>>> s.union(t)
{1.1, 1, (8+9j), 4, 7, 'hello', 'a', 'abc', 'c', 'b'}
>>> len(s),len(t), len(s.union(t))
(8, 3, 10)
DISECTANDO LA CLASE set.
Como ya se ha vuelto costumbre, podemos revisar la estructura de un objeto conjunto usando la función dir().
>>dir(set)
['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
Como ya se ha vuelto costumbre, podemos revisar la estructura de un objeto conjunto usando la función dir().
>>dir(set)
['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
CONVERSIONES ENTRE TIPOS DE DATOS
Ya vimos que podíamos convertir datos nativos entre ellos.Repasemos y ampliemos esas conversiones.
TIPOS DE DATOS SIMPLES.
Dado que Python es un lenguaje orientado a objetos, la creación de un objeto permite que se haga desde un constructor o inicializador que corresponde a otro tipo de dato, y Python se encarga de hacer la respectiva conversión.
Entonces, prácticamente cualquier tipo puede ser convertido a otro tipo con solo crear el valor a partir de otro tipo diferente.
Como una excepción está el tipo de dato complex, el cual no puede ser transformado sino a string y desde string.
>>> (str(9), float("5"), int(5.6), str(9.8), float("9.8"), float(3))
('9', 5.0, 5, '9.8', '9', 9.8, 3.0)
>>> (int(9.8), int("9"), bool(9), bool(0))
(9, 9, True, False)
>>> (bool("1"), bool(""), str(True), str(False))
(True, False, 'True', 'False')
Note que una cadena de caracteres convertida a booleano es False si es una cadena vacía. Por lo tanto bool("0") es True.
>>> bool("0")
True
Los números complejos también pueden ser convertidos desde y hacia cadenas de caracters.
>>> ( complex('9.8+0j'), str(9.8 + 5.4j) )
((9.8+0j), '(9.8+5.4j)')
TIPOS DE DATOS COMPUESTOS.
Qué pasa si queremos convertir un dato simple como un int, float, complex, o string en una lista?
Sólo los datos iterables podrían ser llevados a una lista; es por eso que, de entre los tipos int, float, complex y string, sólo las strings son iterables, por lo que:
>>> list("data")
['d', 'a', 't', 'a']
TIPOS DE DATOS SIMPLES.
Dado que Python es un lenguaje orientado a objetos, la creación de un objeto permite que se haga desde un constructor o inicializador que corresponde a otro tipo de dato, y Python se encarga de hacer la respectiva conversión.
Entonces, prácticamente cualquier tipo puede ser convertido a otro tipo con solo crear el valor a partir de otro tipo diferente.
Como una excepción está el tipo de dato complex, el cual no puede ser transformado sino a string y desde string.
>>> (str(9), float("5"), int(5.6), str(9.8), float("9.8"), float(3))
('9', 5.0, 5, '9.8', '9', 9.8, 3.0)
>>> (int(9.8), int("9"), bool(9), bool(0))
(9, 9, True, False)
>>> (bool("1"), bool(""), str(True), str(False))
(True, False, 'True', 'False')
Note que una cadena de caracteres convertida a booleano es False si es una cadena vacía. Por lo tanto bool("0") es True.
>>> bool("0")
True
Los números complejos también pueden ser convertidos desde y hacia cadenas de caracters.
>>> ( complex('9.8+0j'), str(9.8 + 5.4j) )
((9.8+0j), '(9.8+5.4j)')
TIPOS DE DATOS COMPUESTOS.
Qué pasa si queremos convertir un dato simple como un int, float, complex, o string en una lista?
Sólo los datos iterables podrían ser llevados a una lista; es por eso que, de entre los tipos int, float, complex y string, sólo las strings son iterables, por lo que:
>>> list("data")
['d', 'a', 't', 'a']
- Las listas, diccionarios y conjuntos pueden ser concertidos a strings:
>>> s = set() ; l = list() ;d = dict()
>>> s.add(8) ; l.append(8) ; d[8]="ocho"
>>> s
{8}
>>> l
[8]
>>> d
{8: 'ocho'}
>>> str(s)
'{8}'
>>> str(l)
'[8]'
>>> str(d)
"{8: 'ocho'}
POSICIÓN DE OBJETOS EN MEMORIA
Python sabe para cada variable dónde guarda su valor. Todo valor en Python está ubicado en una localización de memoria. Las localizaciones en memoria pueden ser conocidas. Se trata de una dirección, y para saber cuál es la dirección en memoria asociado a una variable, se usa la función id( ). La función id( ) entrega un número entero que corresponde a una dirección en memoria.
En Python, conocer esta dirección no es realmente muy importante cuando se está trabajando con aplicaciones tradicionales. Sin embargo, podría ser útil si su aplicación es más especializada que eso.
>>> a=8
>>> x=id(a)
>>> hex(x)
'0x10112eb80'
En el caso que se tenga la dirección de la variable, el valor se puede acceder de la siguiente manera:
Lo primero es importar la librería ctypes.
>>>import ctypes
Luego, se usa el método cast del objeto ctypes.
>>>ctypes.cast(x, ctypes.py_object).value
8
Esta estrategia es válida para cualquier objeto en Python. Sin embargo, no es común estar necesitando conocer las direcciones en memoria de los objetos, o andar recuperando valores usando dicha dirección. Sin embargo, este tipo de cultura general es interesante.
En Python, conocer esta dirección no es realmente muy importante cuando se está trabajando con aplicaciones tradicionales. Sin embargo, podría ser útil si su aplicación es más especializada que eso.
>>> a=8
>>> x=id(a)
>>> hex(x)
'0x10112eb80'
En el caso que se tenga la dirección de la variable, el valor se puede acceder de la siguiente manera:
Lo primero es importar la librería ctypes.
>>>import ctypes
Luego, se usa el método cast del objeto ctypes.
>>>ctypes.cast(x, ctypes.py_object).value
8
Esta estrategia es válida para cualquier objeto en Python. Sin embargo, no es común estar necesitando conocer las direcciones en memoria de los objetos, o andar recuperando valores usando dicha dirección. Sin embargo, este tipo de cultura general es interesante.
SESIÓN #3 DE EJERCITACIÓN: TIPOS DE DATOS EN LA CONSOLA PYTHON
- Cree una variable entera, una real, una string, y una booleana con los valores que desee.
-Consulte el tipo de las variables y compruebe que lo hizo bien.
-Consulte la estructura interna de las variables con el comando dir().
-Intente establecer diferencias sobre las clases. - Cree una variable que contenga una lista con 3 valores de tipo: real, entero, string y booleano y presente la variable para verificar cómo quedó la lista.
-Extraiga de la lista el primer elemento
-Pregunte por el tipo del tercer elemento
-Modifique el cuarto elemento por otro del mismo tipo y presente la variable para verificar cómo quedó la lista. - Cree una variable que contenga una tupla con 4 valores de tipo: real, entero, string y booleano y presente la variable para verificar cómo quedó la tupla.
-Extraiga de la tupla el primer elemento de la tupla.
-Pregunte por el tipo del tercer elemento de la tupla.
-Modifique el cuarto elemento por otro del mismo tipo. ¿Qué pasa? - Cree una variable que contenga un conjunto, con 4 valores de tipo: real, entero, string y booleano y presente la variable para verificar cómo quedó el conjunto.
Cree otra variable que contenga otro conjunto, con 2 valores, donde uno de ellos ya existe en el conjunto anterior.
-Determine el conjunto intersección.
-Determine el conjunto unión.
-Determine la longitud del conjunto intersección.
-Determine la longitud del conjunto unión. - Cree una variable que contenga un diccionario. El diccionario contendrá información de 4 números cualquiera de la siguiente manera: la clave son números enteros, y el valor asociado a cada clave es el nombre del número usando como clave(string). Por ejemplo, si usted elije usar la clave 30, el valor será la string “treinta”.
Luego de asociado el diccionario a la variable, presente la variable para comprobar el contenido. Proceda con las siguientes acciones sobre el diccionario.
Extraiga de la lista uno de los valores usando alguna de las claves.
Intente Extraer un valor de una clave que no existe. ¿Qué pasa?
Modifique uno de los elementos del diccionario y compruebe cómo quedó el diccionario.¿Cómo lo hizo? - Cree un diccionario con dos valores, cuyas claves son “ENT” y “REAL”. Use un valor entero para “ENT” y un valor float para “REAL”. A continuación, lleva a cabo las siguientes acciones:
Adicione al diccionario una nueva entrada con clave “S-INT” y cuyo valor sea una string que contenga un número entero.
Adicione al diccionario una nueva entrada con clave “S-FLOAT” y cuyo valor sea una cadena que contenga un número de punto flotante.
Convierta a entero la cadena con el número entero.
Convierta a flotante la cadena con el número entero.
Convierta a entero la cadena con el número flotante.
Convierta a flotante la cadena con el número real.
Adicione al diccionario una nueva entrada “BOOL” con valor booleano cualquiera.
Convierta la variable booleana a entero.
Cree una expresión que invierta el valor actual del valor booleano. - Crear una lista con 3 elementos. El segundo elemento de la lista contiene una lista vacía. Y el último tiene una lista con dos elementos, uno entero y otro real. Consulte el tipo del tercer elemento.
- Cree una tupla de tres elementos. El primer elemento es un diccionario. El segundo elemento es otro diccionario. Cada uno de los diccionarios tiene dos claves con valor. El tercer elemento de la tupla contiene dos listas. La primera lista contiene tres elementos de números reales. La segunda lista en la tupla contiene un valor booleano, una string, y un número.
-Luego de creada la estructura, consulte con una sola expresión la string, y con otra única expresión consulte el segundo valor del diccionario en la segunda posición. - Diccionarios. Construya un diccionario con tres elementos con claves 100, 200 y 300. La primera clave del diccionario contiene un diccionario con las claves 110, 120, y 130, cada valor de elemento con strings vacías. La entrada 200 tiene un diccionario con claves ‘A’ y ‘B’, cada entrada con dos listas empaquetadas en tupla, cada lista con dos elementos tupla de tres valores enteros cualquiera. Y la entrada 300, tiene el valor None.
- Listas anidadas. Construya una lista de tres elementos, donde cada posición de la lista es una lista con tres elementos, donde cada posición de esas listas es una lista con dos elementos, donde cada posición de esas listas es una lista con tres listas vacías.
- Relación de sumas. Una tupla contiene, en su orden, una lista de dos elementos, y una tupla de tres elementos. Compruebe si la suma de los dos primeros elementos de la lista, es mayor a la suma de los dos últimos elementos de la tupla. Use sólo una expresión.
EXPRESIONES EN PYTHON
Python en un lenguaje orientado a objetos. De hecho, toda variable en Python es un objeto, lo que significa que muchas operaciones se ejecutan directamente dentro de alguno de los objetos involucrados.
Una operación como la suma entre dos objetos dependerá de las funciones de los objetos involucrados.
>>> 5 + 4
9
>>> (5).__add__(4)
9
>>> (5 + 4)/3
3
>>> (5).__add__(4).__floordiv__(3)
3
>>>
OPERADOR DE ASIGNAMIENTO.
El Python, como en muchos lenguajes procedurales, el operador de asignación de valor es el caracter igual (=), que se evalúa de derecha a izquierda.
El operador = de Python equivale al operador <- de asociación de nuestros pseudocódigos.
Es importante no confundir el operador de asignación = con el operador relacional de igualdad de los pseudocódigos: en el caso de los pseudocódigos no debería haber confusión, ya que el operador de asociación es la flecha (<-).
Pero, solo por precaución, en los pseudocódigos a veces se han escrito expresiones relacionales de igualdad usando .EQ. y no =. En pseudocódigo, La otra posibilidad es usar el operador == en para evitar confusión.
En resumen, en Python este operador relaciona el nombre de la izquierda con el objeto de la derecha.
Por ejemplo:
>>> x = 3 #se crea el objeto 3 y se asocia a la variable x.
>>> x
3
Por simplicidad en la forma de hablar, diremos que se asigna el valor 3 a la variable x, y seguiremos hablando de variables.
Un asignamiento en cascada también es posible en Python:
>>> x = r = y = 9
>>> x * r * y
729
>>>
ASIGNAMIENTO DE TUPLA.
En Python es posible asignar simultáneamente una lista de valores a una lista de variables. Es puede simplificar un poco la escritura.
Este modelo es una simplificación del tipo de dato tupla. Esto es, para Python un conjunto de valores separados con el caracter coma ( , ) es realmente un objeto tipo tupla.
>>> x = (300, 200)
>>> x
(300, 200)
>>> type(x)
<type 'tuple'>
Para asignar un conjunto de valores a un conjunto de variables de forma simultánea puede usar una tupla, y python desempaqueta la tupla asignando un valor a cada variable. Incluso no requiere usar paréntesis.
>>> x, y, z = 8, 16, 25
>>> x
8
>>> y
16
>>> z
25
Dado que es posible hacer la asociación de valores simultaneo a varias variables, hay un uso particularmente práctico de esta técnica multivaluada: para intercambiar dos valores, solo vasta con reasignarlos en una sola lista.
>>> x = 10
>>> y = 20
>>> x,y = y,x
>>> x
20
>>> y
10
>>>
EXPRESIONES INTERMEDIAS NOMBRADAS
Una expresión nombrada es aquella que asigna su valor a una variable, usando el operador especial := ( que en inglés se le llama ‘named expression operator’).
El uso de este operador es importante en algunos contextos, donde el lenguaje puede emitir mensajes de error.
Por ejemplo, suponga que usted requiere asignar el valor a una variable durante la comprobación de un if, o tiene expresiones dentro de otras expresiones que requieren dejar un valor en una variable durante la acción:
>>> a = (c:= (b:= 8 + 5) + 10 ) + 20
>>> (a, b, c)
(43, 13, 23)
>>>
Se evalúa primero la expresión más interna en la que b se asocia al valor 13, luego se suma 10 para obtener 23, y ese valor se asocia a a la variable c. finalmente se suma 20 para obtener 43, y ese valor se asocia a la variable a.
Las variables a, b y c son diferentes, y todas obtuvieron su valor dentro de la misma expresión.
La variable más a la derecha no necesita ser asignada con operador igual, y podría haber sido una expresión nombrada también que deja libre su valor:
>>> (a := (c:= (b:= 8 + 5) + 10 ) + 20)
43
>>> (a, b, c)
(43, 13, 23)
>>>
que funciona de la misma manera que el anterior, con la única diferencia que luego de asignado el valor a la variable a, la expresión queda disponible para ser usada por la consola REPL de Python.
Una operación como la suma entre dos objetos dependerá de las funciones de los objetos involucrados.
>>> 5 + 4
9
>>> (5).__add__(4)
9
>>> (5 + 4)/3
3
>>> (5).__add__(4).__floordiv__(3)
3
>>>
OPERADOR DE ASIGNAMIENTO.
El Python, como en muchos lenguajes procedurales, el operador de asignación de valor es el caracter igual (=), que se evalúa de derecha a izquierda.
El operador = de Python equivale al operador <- de asociación de nuestros pseudocódigos.
Es importante no confundir el operador de asignación = con el operador relacional de igualdad de los pseudocódigos: en el caso de los pseudocódigos no debería haber confusión, ya que el operador de asociación es la flecha (<-).
Pero, solo por precaución, en los pseudocódigos a veces se han escrito expresiones relacionales de igualdad usando .EQ. y no =. En pseudocódigo, La otra posibilidad es usar el operador == en para evitar confusión.
En resumen, en Python este operador relaciona el nombre de la izquierda con el objeto de la derecha.
Por ejemplo:
>>> x = 3 #se crea el objeto 3 y se asocia a la variable x.
>>> x
3
Por simplicidad en la forma de hablar, diremos que se asigna el valor 3 a la variable x, y seguiremos hablando de variables.
Un asignamiento en cascada también es posible en Python:
>>> x = r = y = 9
>>> x * r * y
729
>>>
ASIGNAMIENTO DE TUPLA.
En Python es posible asignar simultáneamente una lista de valores a una lista de variables. Es puede simplificar un poco la escritura.
Este modelo es una simplificación del tipo de dato tupla. Esto es, para Python un conjunto de valores separados con el caracter coma ( , ) es realmente un objeto tipo tupla.
>>> x = (300, 200)
>>> x
(300, 200)
>>> type(x)
<type 'tuple'>
Para asignar un conjunto de valores a un conjunto de variables de forma simultánea puede usar una tupla, y python desempaqueta la tupla asignando un valor a cada variable. Incluso no requiere usar paréntesis.
>>> x, y, z = 8, 16, 25
>>> x
8
>>> y
16
>>> z
25
Dado que es posible hacer la asociación de valores simultaneo a varias variables, hay un uso particularmente práctico de esta técnica multivaluada: para intercambiar dos valores, solo vasta con reasignarlos en una sola lista.
>>> x = 10
>>> y = 20
>>> x,y = y,x
>>> x
20
>>> y
10
>>>
EXPRESIONES INTERMEDIAS NOMBRADAS
Una expresión nombrada es aquella que asigna su valor a una variable, usando el operador especial := ( que en inglés se le llama ‘named expression operator’).
El uso de este operador es importante en algunos contextos, donde el lenguaje puede emitir mensajes de error.
Por ejemplo, suponga que usted requiere asignar el valor a una variable durante la comprobación de un if, o tiene expresiones dentro de otras expresiones que requieren dejar un valor en una variable durante la acción:
>>> a = (c:= (b:= 8 + 5) + 10 ) + 20
>>> (a, b, c)
(43, 13, 23)
>>>
Se evalúa primero la expresión más interna en la que b se asocia al valor 13, luego se suma 10 para obtener 23, y ese valor se asocia a a la variable c. finalmente se suma 20 para obtener 43, y ese valor se asocia a la variable a.
Las variables a, b y c son diferentes, y todas obtuvieron su valor dentro de la misma expresión.
La variable más a la derecha no necesita ser asignada con operador igual, y podría haber sido una expresión nombrada también que deja libre su valor:
>>> (a := (c:= (b:= 8 + 5) + 10 ) + 20)
43
>>> (a, b, c)
(43, 13, 23)
>>>
que funciona de la misma manera que el anterior, con la única diferencia que luego de asignado el valor a la variable a, la expresión queda disponible para ser usada por la consola REPL de Python.
OPERADORES ARITMÉTICOS
Los números enteros, reales y complejos son objetos que contienen funciones especiales para hacer aritmética. Los operadores aritméticos binarios básicos son:
La suma, operador +, - , * , / , % , ** y //, que se asocia a la funciones suma, multiplicación, resta, división , módulo, potencia y división piso, respectivamente.
Todo número en Python es un objeto que contiene funciones asociadas a estos operadores. Las funciones binarias asociadas a los operadores aritméticos presentados son, en su orden, __add__ , __sub__ , __mul__ , __truediv__ , __mod__ , __pow__( ) , __floordiv( ).
>>> x=2
>>> y=4
>>> z=6
>>> ( x + y + z ) ** ( x + y )
2985984
>> x.__add__(y).__add__(z).__pow__(x.__add__(y))
2985984
Todo operador tiene dos contrapartes, que se llaman casi igual con la diferencia del prefijo r, el cual es usado solo cuando el objeto que hace la llamada no soporta la operación, o cuando deseamos invertir la operación, a saber, __radd__, __rsub__, __rmul__, __rtruediv__, __rmod__, __rpow__, __rfloordiv__.
>>> x,y=10.5,20.3
>>> x
10.5
>>> y
20.3
>>> x.__div__(y)
0.5172413793103449
>>> x.__rdiv__(y)
1.9333333333333333
>>> y.__rdiv__(x)
0.5172413793103449
>>> y.__div__(x)
1.9333333333333333
>>>
Esta lista de funciones puede revisarlas para el objeto int de su versión de Python a través de la función dir( ).
>>dir(int)
['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']
PRIORIDAD DE LOS OPERADORES ARITMÉTICOS.
Para detalles sobre el significado de las prioridades en los operadores, ver el tema de Prioridad en capítulos previos.
En Python, el orden de prioridad se describe así:
El operador potencia ** tiene la mayor prioridad aritmética.
Le siguen los operadores unarios + y -.
Siguen los operadores *, /, //, %. Entre ellos no hay prioridad, y evalúan de izquierda a derecha.
Por último, los operadores unarios + y -.
La anterior precedencia de operadores concuerda con la analizada anteriormente en pseudocódigo. Para resolver sobre el orden que se desean las operaciones, se debe utilizar paréntesis.
>>> 3+4**2
19
>>> (3+4)**2
49
>>>
Los operadores binarios pueden ser conjugados con los operadores unarios. En este cao, el interpretador tratará de simplificar los operadores unarios al máximo:
>>> 3+++---++++---4
7
>>> 3+++---++++----4
-1
>>> 3-4
-1
>>>
>>> 3*++++4/----5
2
>>> 3*4/5
2
>>>
La suma, operador +, - , * , / , % , ** y //, que se asocia a la funciones suma, multiplicación, resta, división , módulo, potencia y división piso, respectivamente.
Todo número en Python es un objeto que contiene funciones asociadas a estos operadores. Las funciones binarias asociadas a los operadores aritméticos presentados son, en su orden, __add__ , __sub__ , __mul__ , __truediv__ , __mod__ , __pow__( ) , __floordiv( ).
>>> x=2
>>> y=4
>>> z=6
>>> ( x + y + z ) ** ( x + y )
2985984
>> x.__add__(y).__add__(z).__pow__(x.__add__(y))
2985984
Todo operador tiene dos contrapartes, que se llaman casi igual con la diferencia del prefijo r, el cual es usado solo cuando el objeto que hace la llamada no soporta la operación, o cuando deseamos invertir la operación, a saber, __radd__, __rsub__, __rmul__, __rtruediv__, __rmod__, __rpow__, __rfloordiv__.
>>> x,y=10.5,20.3
>>> x
10.5
>>> y
20.3
>>> x.__div__(y)
0.5172413793103449
>>> x.__rdiv__(y)
1.9333333333333333
>>> y.__rdiv__(x)
0.5172413793103449
>>> y.__div__(x)
1.9333333333333333
>>>
Esta lista de funciones puede revisarlas para el objeto int de su versión de Python a través de la función dir( ).
>>dir(int)
['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']
PRIORIDAD DE LOS OPERADORES ARITMÉTICOS.
Para detalles sobre el significado de las prioridades en los operadores, ver el tema de Prioridad en capítulos previos.
En Python, el orden de prioridad se describe así:
El operador potencia ** tiene la mayor prioridad aritmética.
Le siguen los operadores unarios + y -.
Siguen los operadores *, /, //, %. Entre ellos no hay prioridad, y evalúan de izquierda a derecha.
Por último, los operadores unarios + y -.
La anterior precedencia de operadores concuerda con la analizada anteriormente en pseudocódigo. Para resolver sobre el orden que se desean las operaciones, se debe utilizar paréntesis.
>>> 3+4**2
19
>>> (3+4)**2
49
>>>
Los operadores binarios pueden ser conjugados con los operadores unarios. En este cao, el interpretador tratará de simplificar los operadores unarios al máximo:
>>> 3+++---++++---4
7
>>> 3+++---++++----4
-1
>>> 3-4
-1
>>>
>>> 3*++++4/----5
2
>>> 3*4/5
2
>>>
OPERADORES LÓGICOS
Los operadores lógicos en Python son and, or y not, que ya fueron explorados en detalle en capítulos previos. Los operadores en Python cumplen con las reglas de cortocircuito vistas en la sección de expresiones lógicas.
La función AND y OR tienen equivalencias en los objetos, que corresponden a los métodos de clase __and__ y __or__ respectivamente, y sus contrapartes __rand__ y __ror__.
La función unaria not no se encuentra disponible en las clases, y muy seguramente se implementa a través de la inversión de la función __bool__ disponible en los objetos int, float y bool, y la función __len__ disponible en objetos de tipo colecciones, como listas, tuplas y diccionarios.
Al revisar la clase int que se revisó anteriormente, podremos encontrar estas funciones como parte del objeto entero.
En Python, un valor entero distinto de cero es True, y un valor igual a cero es False.
Si se trata de una colección vacía, está será False. De lo contrario, será True.
>>> (bool(5), bool(7.2), bool("x"))
(True, True, True)
>>> (bool(0), bool(0.0), bool(""))
(False, False, False)
Desde la otra óptica, un valor False es 0 y un valor True es 1.
>>> (int(False),int(True))
(0, 1)
>>> (float(False), float(True))
(0.0, 1.0)
>>>
Dicho esto, se tiene por ejemplo que
>>> 8 and 0
0
>>> 0 and 8
0
>>> 8 or 0
8
>>> 0 or 8
8
Una revisión a las tablas de valores de verdad vista cuando se vio el tema de operadores relacionales, y un entendimiento de la filosofía de los cortocircuitos son la respuesta a este comportamiento.
En el primer caso, 8 es True, por lo que se debe revisar el segundo valor, lo que deja en la expresión el resultado de 0. En el segundo caso, 0 es False, y por tal motivo es suficiente para que el cortocircuito deje como valor el 0, sin seguir adelante.
En el tercer ejemplo, 8 es suficiente para determinar que no es necesario seguir, por lo que el cortocircuito deja como valor el 8 y no sigue adelante con la expresión. En el último caso, por el contrario, 0 no es suficiente para determinar el valor de verdad de la expresión, por lo que se pasa al 8, y ese es el valor de la expresión.
PRIORIDAD DE LOS OPERADORES LÓGICOS.
Los operadores lógicos también consideran prioridad. Eso significa que, al ensamblar nuestras expresiones lógicas, debemos entender cómo funcionan y en qué orden, de tal modo que si queremos establecer un orden concreto, podamos modificar el orden de evaluación con paréntesis, o reestructurando su orden dentro dela expresión.
En Python, el orden de evaluación es el siguiente:
Los operadores aritméticos tienen mayor prioridad que el operador not
>>> not 3 +4
False
En este caso, el operador + prima sobre el operador not, por lo que se evalúa primero la suma, y la expresión not 4+3 nos lleva a la expresión temporal not 7. Dado que 7 es True, nos lleva a not True, lo que da como resultado False.
El operador not tiene más prioridad que el operador and y el operador or.
El operador and tiene más prioridad que el operador or.
>>> False and False or True and True
True
>>>
Dado que and tiene más prioridad que or, la expresión evalúa primero los dos and, y queda la expresión False or True, lo que nos lleva a True.
Veamos qué pasaría si no fuera cierto que and prima sobre OR: se evaluaría primero False or True que nos dejaría en True, y finalmente tendríamos False and True and False, que sería False.
¡Pero no fue así! Queda comprobado que and prima sobre OR.
>>> False and False or True
True
>>> False and (False or True)
False
>>>
>>> (not False) or True
True
>>> not (False or True)
False
La función AND y OR tienen equivalencias en los objetos, que corresponden a los métodos de clase __and__ y __or__ respectivamente, y sus contrapartes __rand__ y __ror__.
La función unaria not no se encuentra disponible en las clases, y muy seguramente se implementa a través de la inversión de la función __bool__ disponible en los objetos int, float y bool, y la función __len__ disponible en objetos de tipo colecciones, como listas, tuplas y diccionarios.
Al revisar la clase int que se revisó anteriormente, podremos encontrar estas funciones como parte del objeto entero.
En Python, un valor entero distinto de cero es True, y un valor igual a cero es False.
Si se trata de una colección vacía, está será False. De lo contrario, será True.
>>> (bool(5), bool(7.2), bool("x"))
(True, True, True)
>>> (bool(0), bool(0.0), bool(""))
(False, False, False)
Desde la otra óptica, un valor False es 0 y un valor True es 1.
>>> (int(False),int(True))
(0, 1)
>>> (float(False), float(True))
(0.0, 1.0)
>>>
Dicho esto, se tiene por ejemplo que
>>> 8 and 0
0
>>> 0 and 8
0
>>> 8 or 0
8
>>> 0 or 8
8
Una revisión a las tablas de valores de verdad vista cuando se vio el tema de operadores relacionales, y un entendimiento de la filosofía de los cortocircuitos son la respuesta a este comportamiento.
En el primer caso, 8 es True, por lo que se debe revisar el segundo valor, lo que deja en la expresión el resultado de 0. En el segundo caso, 0 es False, y por tal motivo es suficiente para que el cortocircuito deje como valor el 0, sin seguir adelante.
En el tercer ejemplo, 8 es suficiente para determinar que no es necesario seguir, por lo que el cortocircuito deja como valor el 8 y no sigue adelante con la expresión. En el último caso, por el contrario, 0 no es suficiente para determinar el valor de verdad de la expresión, por lo que se pasa al 8, y ese es el valor de la expresión.
PRIORIDAD DE LOS OPERADORES LÓGICOS.
Los operadores lógicos también consideran prioridad. Eso significa que, al ensamblar nuestras expresiones lógicas, debemos entender cómo funcionan y en qué orden, de tal modo que si queremos establecer un orden concreto, podamos modificar el orden de evaluación con paréntesis, o reestructurando su orden dentro dela expresión.
En Python, el orden de evaluación es el siguiente:
Los operadores aritméticos tienen mayor prioridad que el operador not
>>> not 3 +4
False
En este caso, el operador + prima sobre el operador not, por lo que se evalúa primero la suma, y la expresión not 4+3 nos lleva a la expresión temporal not 7. Dado que 7 es True, nos lleva a not True, lo que da como resultado False.
El operador not tiene más prioridad que el operador and y el operador or.
El operador and tiene más prioridad que el operador or.
>>> False and False or True and True
True
>>>
Dado que and tiene más prioridad que or, la expresión evalúa primero los dos and, y queda la expresión False or True, lo que nos lleva a True.
Veamos qué pasaría si no fuera cierto que and prima sobre OR: se evaluaría primero False or True que nos dejaría en True, y finalmente tendríamos False and True and False, que sería False.
¡Pero no fue así! Queda comprobado que and prima sobre OR.
>>> False and False or True
True
>>> False and (False or True)
False
>>>
>>> (not False) or True
True
>>> not (False or True)
False
OPERADORES RELACIONALES
Los operadores relacionales en Python son
== (igual), != (diferente), > (mayor que), < (menor que), >= (mayor o igual) ,<= (menor o igual).
En Python, esta es la única forma de escribirlos y no existen operadores sinónimos como vimos en el trabajo con pseudocódigos. Sin embargo, sí existen funciones especiales en los objetos tipo float y tipo entero (y bool que hereda de entero).
Las funciones relacionales son __eq__, __ne__, __gt__, __lt__, __ge__ y __le__ respectivamente.
>>> (8.9).__lt__(9.2)
>>> True
>>> 8.9 < 9.2
True
>>> (5).__ge__(5)
True
>>> (4).__le__(4)
True
>>> (8).__ne__(8)
False
CONECTIVIDAD RELACIONAL EN CASCADA
En Python, al igual con algunos otros lenguajes, es posible establecer comparaciones en cascada.
Esto equivale a evitar escribir el operador and, y elimina la necesidad de repetir operandos.
>>> 3 <= 4 and 4 < 5 and 5 <= 5 and 5 < 10 and 10 < 100
True
que se puede escribir como:
>>> 3 <= 4 < 5 <= 5 < 10 < 100
True
OPERADOR DE IGUALDAD is, is not.
Operador de igualdad de identidad is, is not.
Cuando se necesita saber si dos objetos en Python son el mismo, se usa el operador is, o su negación is not. Este operador compruebra si dos objetos cualquier son el mismo.
>>>
>>> x=[1,2,3,4,5] #x es una lista
>>> y=[1,2,3,4,5] #y es otra lista con los mismos elementos que x
>>> z=x #z es x
>>> x is y #x y y no son la misma lista
False
>>> y is z #z y y no son la misma lista
False
>>> z is x #z es x
True
>>> x is not y
True
>>>
La razón para que x sea un objeto distinto, es que ambos apuntan a dos listas, que aunque contienen elementos iguales, son dos listas diferentes.
Para indagar si los valores de la lista son los mismos, se debe usar el operador ==.
>>> x==y
True
>>>
Dicho de otro modo, x no es y pero x es igual a y, y x es z además de que x es igual a z.
>>> x is not y and x == y
True
>>> x is z and x == z
True
>>>
En realidad, el operador is verifica la dirección en memoria de los objetos. Por lo tanto:
>>> id(x) == id(z)
True
>>> id(x) != id(y)
True
>>> id(y) != id(z)
True
>>>
PRIORIDAD DE LOS OPERADORES RELACIONALES.
Dada la conectiva relacional presentada en el aparte anterior, los operadores relacionales no presentan una prioridad específica entre ellos como presentan los operadores lógicos o aritméticos. Por tal motivo, no podemos compararlos entre ellos.
La conectiva relacional en cascada entra en vigor cuando tenemos una combinación del operador igual o diferente con los demás operadores.
Veamos:
>>> 4 <= 4 == 2 <= 3
False
Suponiendo que el operador == tenga menor prioridad (lo que no es cierto), los demás operadores permitirían agrupar y evaluar 4 <= 4 y 2<=3, llevándonos finalmente a una comparación True == True, y por consiguiente el valor final sería True. ¡Esto no es cierto!
Lo que realmente va a suceder es que entra a regir la conectiva relacional en cascada, por lo que se procede como 4 <= 4 and 4 == 2 and 2 <= 3; en su orden se da 4 <= 4 como True, 4 == 2 como False y 2 <= 3 como True. Finalmente uniremos True and False, y por cortocircuito and, el valor es False.
Donde sí se dan prioridades es cuando se escriben operaciones relacionales que involucren operadores aritméticos o lógicos.
Los operadores aritméticos tendrán mayor prioridad que los operadores relacionales; si no fuera así, se generarían expresiones que no podrían ser fácilmente evaluadas, y la escritura de ellas requeriría de un uso intensivo de paréntesis para hacer asociaciones que determinen la prioridad.
Para la expresión
>>> 4 == 5 - 1
True
Tenemos que prima el operador menos sobre el operador igual, por lo que primero llegamos a la expresión 4 == 4 y finalmente eso nos deja en un valor reducido de True.
En el caso de la expresión
>>> 4 == 5 - 20/20
True
Se llega primero a la expresión 4 == 5 – 1, antes de proceder a 4 == 4, y por último True.
Con los operadores lógicos pasa lo contrario a los aritméticos, y tienen menor prioridad que los operadores relacionales. Esto es, primero evaluamos operadores relacionales, y finalmente hacemos las conectivas lógicas.
>>> 5 < 4 and 2 <= 3
False
Note que primero evaluamos 5 < 4, lo que nos deja en False, y por cortocircuito and ya no seguiremos adelante con la evaluación.
También note que en
>>> 4 < 5 and 3 < 2
False
Se evalúa primero 4 < 5 que nos lleva a True, lo que obliga a evaluar 3 < 2 que nos lleva a False, y finalmente tendremos True and False que nos lleva a False.
== (igual), != (diferente), > (mayor que), < (menor que), >= (mayor o igual) ,<= (menor o igual).
En Python, esta es la única forma de escribirlos y no existen operadores sinónimos como vimos en el trabajo con pseudocódigos. Sin embargo, sí existen funciones especiales en los objetos tipo float y tipo entero (y bool que hereda de entero).
Las funciones relacionales son __eq__, __ne__, __gt__, __lt__, __ge__ y __le__ respectivamente.
>>> (8.9).__lt__(9.2)
>>> True
>>> 8.9 < 9.2
True
>>> (5).__ge__(5)
True
>>> (4).__le__(4)
True
>>> (8).__ne__(8)
False
CONECTIVIDAD RELACIONAL EN CASCADA
En Python, al igual con algunos otros lenguajes, es posible establecer comparaciones en cascada.
Esto equivale a evitar escribir el operador and, y elimina la necesidad de repetir operandos.
>>> 3 <= 4 and 4 < 5 and 5 <= 5 and 5 < 10 and 10 < 100
True
que se puede escribir como:
>>> 3 <= 4 < 5 <= 5 < 10 < 100
True
OPERADOR DE IGUALDAD is, is not.
Operador de igualdad de identidad is, is not.
Cuando se necesita saber si dos objetos en Python son el mismo, se usa el operador is, o su negación is not. Este operador compruebra si dos objetos cualquier son el mismo.
>>>
>>> x=[1,2,3,4,5] #x es una lista
>>> y=[1,2,3,4,5] #y es otra lista con los mismos elementos que x
>>> z=x #z es x
>>> x is y #x y y no son la misma lista
False
>>> y is z #z y y no son la misma lista
False
>>> z is x #z es x
True
>>> x is not y
True
>>>
La razón para que x sea un objeto distinto, es que ambos apuntan a dos listas, que aunque contienen elementos iguales, son dos listas diferentes.
Para indagar si los valores de la lista son los mismos, se debe usar el operador ==.
>>> x==y
True
>>>
Dicho de otro modo, x no es y pero x es igual a y, y x es z además de que x es igual a z.
>>> x is not y and x == y
True
>>> x is z and x == z
True
>>>
En realidad, el operador is verifica la dirección en memoria de los objetos. Por lo tanto:
>>> id(x) == id(z)
True
>>> id(x) != id(y)
True
>>> id(y) != id(z)
True
>>>
PRIORIDAD DE LOS OPERADORES RELACIONALES.
Dada la conectiva relacional presentada en el aparte anterior, los operadores relacionales no presentan una prioridad específica entre ellos como presentan los operadores lógicos o aritméticos. Por tal motivo, no podemos compararlos entre ellos.
La conectiva relacional en cascada entra en vigor cuando tenemos una combinación del operador igual o diferente con los demás operadores.
Veamos:
>>> 4 <= 4 == 2 <= 3
False
Suponiendo que el operador == tenga menor prioridad (lo que no es cierto), los demás operadores permitirían agrupar y evaluar 4 <= 4 y 2<=3, llevándonos finalmente a una comparación True == True, y por consiguiente el valor final sería True. ¡Esto no es cierto!
Lo que realmente va a suceder es que entra a regir la conectiva relacional en cascada, por lo que se procede como 4 <= 4 and 4 == 2 and 2 <= 3; en su orden se da 4 <= 4 como True, 4 == 2 como False y 2 <= 3 como True. Finalmente uniremos True and False, y por cortocircuito and, el valor es False.
Donde sí se dan prioridades es cuando se escriben operaciones relacionales que involucren operadores aritméticos o lógicos.
Los operadores aritméticos tendrán mayor prioridad que los operadores relacionales; si no fuera así, se generarían expresiones que no podrían ser fácilmente evaluadas, y la escritura de ellas requeriría de un uso intensivo de paréntesis para hacer asociaciones que determinen la prioridad.
Para la expresión
>>> 4 == 5 - 1
True
Tenemos que prima el operador menos sobre el operador igual, por lo que primero llegamos a la expresión 4 == 4 y finalmente eso nos deja en un valor reducido de True.
En el caso de la expresión
>>> 4 == 5 - 20/20
True
Se llega primero a la expresión 4 == 5 – 1, antes de proceder a 4 == 4, y por último True.
Con los operadores lógicos pasa lo contrario a los aritméticos, y tienen menor prioridad que los operadores relacionales. Esto es, primero evaluamos operadores relacionales, y finalmente hacemos las conectivas lógicas.
>>> 5 < 4 and 2 <= 3
False
Note que primero evaluamos 5 < 4, lo que nos deja en False, y por cortocircuito and ya no seguiremos adelante con la evaluación.
También note que en
>>> 4 < 5 and 3 < 2
False
Se evalúa primero 4 < 5 que nos lleva a True, lo que obliga a evaluar 3 < 2 que nos lleva a False, y finalmente tendremos True and False que nos lleva a False.
CARACTERES EN PYTHON.
En Python, no existe en concepto de caracter único, o, lo que es lo mismo, no existe un tipo asociado a un único caracter como en otros lenguajes. Un solo caracter en Python es, en realidad, una cadena.
Toda construcción que se haga, en realidad nos dejará siempre en un tipo str (cadena de caracteres).
La función chr( ), que recibe como parámetro un código de caracter, y que tiene como objetivo devolver el caracter correspondiente, devuelve el caracter como valor tipo str.
>>> c = chr(65)
>>> c
'A'
>>> type(c)
<class 'str'>
Toda construcción que se haga, en realidad nos dejará siempre en un tipo str (cadena de caracteres).
La función chr( ), que recibe como parámetro un código de caracter, y que tiene como objetivo devolver el caracter correspondiente, devuelve el caracter como valor tipo str.
>>> c = chr(65)
>>> c
'A'
>>> type(c)
<class 'str'>
SOBRECARGA DE OPERADORES PARA OPERAR STRINGS
SOBRECARGA DE OPERADORES ARITMÉTICOS CON STRINGS
Sobrecargar un caracter significa usarlo para distintos tipos de operaciones. Como vimos anteriormente, un objeto de tipo str cuenta con atributos y métodos que pueden ser consultados. En esa lista encontramos varias funciones que actúan bajo la sombrilla de operadores.
Los operadores matemáticos que son usados por cadenas son +, * y %.
El operador + se asocia a la función __add__, y sirve para concatenar(pegar) dos cadenas, y obtener una nueva.
>>> 'ABC' + '6'
'ABC6'
Y es lo mismo que
>>> 'ABC'.__add__('6')
'ABC6'
El operador * se asocia a la función __mul__ y __rmul__, y sirve para multiplicar cadenas de caracteres. Esto es, repetirlas un número de veces.
>>> 'ABCD' * 6
'ABCDABCDABCDABCDABCDABCD'
Y que es lo mismo que
>>> 'ABCD'.__mul__(6)
'ABCDABCDABCDABCDABCDABCD'
El operador % se asocia a la función __mod__, y sirve para meter contenido dentro de una cadena con formato. El formato debe ser un formato válido.
>>> 'el valor es %d'.__mod__(6)
'el valor es 6'
>>> 'el valor es %s'.__mod__('seis')
'el valor es seis'
SOBRECARGA DE OPERADORES RELACIONALES CON STRING.
Sobrecarga de operadores relacionales con strings.
Las cadenas se pueden comparar lexicográficamente. Esto es, 'A' es mayor que 'B’, y a su vez, 'AB' es menor que 'BC'. También, la cadena 'ABC' es menor que 'ABCD'. Quiere decir que nosotros podemos comparar lexicográficamente dos cadenas usando cualquiera de los operadores relacionales binarios: ==, >=, >, <=, <, y !=. Estos operadores corresponden, en su orden, a las funciones __eq__ , __ge__ , __gt__ , __le__ , __lt__ y __ne__ .
>>> "12345ABCD" <= "12345ABCD"
True
>>>
>>>"" == " "
False
>>>
>>> "ABC" == "aBC"
False
>>>
>>> "ABC" != "ABC"
False
>>>
>>> "xyz" > "XYZ"
True
>>>
Sobrecargar un caracter significa usarlo para distintos tipos de operaciones. Como vimos anteriormente, un objeto de tipo str cuenta con atributos y métodos que pueden ser consultados. En esa lista encontramos varias funciones que actúan bajo la sombrilla de operadores.
Los operadores matemáticos que son usados por cadenas son +, * y %.
El operador + se asocia a la función __add__, y sirve para concatenar(pegar) dos cadenas, y obtener una nueva.
>>> 'ABC' + '6'
'ABC6'
Y es lo mismo que
>>> 'ABC'.__add__('6')
'ABC6'
El operador * se asocia a la función __mul__ y __rmul__, y sirve para multiplicar cadenas de caracteres. Esto es, repetirlas un número de veces.
>>> 'ABCD' * 6
'ABCDABCDABCDABCDABCDABCD'
Y que es lo mismo que
>>> 'ABCD'.__mul__(6)
'ABCDABCDABCDABCDABCDABCD'
El operador % se asocia a la función __mod__, y sirve para meter contenido dentro de una cadena con formato. El formato debe ser un formato válido.
>>> 'el valor es %d'.__mod__(6)
'el valor es 6'
>>> 'el valor es %s'.__mod__('seis')
'el valor es seis'
SOBRECARGA DE OPERADORES RELACIONALES CON STRING.
Sobrecarga de operadores relacionales con strings.
Las cadenas se pueden comparar lexicográficamente. Esto es, 'A' es mayor que 'B’, y a su vez, 'AB' es menor que 'BC'. También, la cadena 'ABC' es menor que 'ABCD'. Quiere decir que nosotros podemos comparar lexicográficamente dos cadenas usando cualquiera de los operadores relacionales binarios: ==, >=, >, <=, <, y !=. Estos operadores corresponden, en su orden, a las funciones __eq__ , __ge__ , __gt__ , __le__ , __lt__ y __ne__ .
>>> "12345ABCD" <= "12345ABCD"
True
>>>
>>>"" == " "
False
>>>
>>> "ABC" == "aBC"
False
>>>
>>> "ABC" != "ABC"
False
>>>
>>> "xyz" > "XYZ"
True
>>>
LA SECUENCIA RANGE
Un rango en Python es un tipo especial de objeto que es capaz de generar una enumeración. Una enumeración es un conjunto de valores enteros comprendidos en un rango que va desde un valor inicial, hasta un valor final, considerando un incremento. Las enumeraciones son muy prácticas cuando quiero recorrer las posiciones de una estructura, como una lista, una tupla, o una cadena de caracteres.
>>> r=range(100)
Miremos cómo se compone la clase del tipo:
>>> dir(r)
['__bool__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index', 'start', 'step', 'stop']
Como se ve, existen tres atributos de la clase range. Usémoslos para aprender un poco más cómo funciona:
>>> r.start
0
>>> r.step
1
>>> r.stop
100
>>>
Tener un rango creado de la manera como se muestra en el ejemplo, significa tener 100 valores, comenzando desde 0, y hasta 100-1, esto es, hasta 99.
start. Es un número entero y es opcional. Si no se especifica asume como valor inicial se especifica automáticamente en 0 (cero).
stop. Es un número entero, y es obligatorio especificarlo; Python siempre resta uno al valor especificado.
step. Es un valor entero, y es opcional. Si no se especifica, el incremento es automáticamente establecido en el valor de 1. El incremento puede ser negativo. Si el incremento es negativo, debe ajustar los valores start y stop acorde al decremento.
Veamos un ejemplo en el que definamos explícitamente el valor inicial, el final, y un incremento distinto de 1, por ejemplo 2:
>>> rp=range(0,10,2)
>>> rp.start
0
>>> rp.stop
10
>>> rp.step
2
Este rango se compone de los valores 0, 2, 4, 6 y 8. Note que el 10 no está disponible en el rango, lo que puede verificar contando el número de veces que aparece. Como se mencionó antes, Python siempre resta 1 al valor dado como stop.
Para verificar si un dato existe o no, puede usar la función count.
>>> rp.count(10)
0
>>> rp.count(1)
0
>>> rp.count(2)
1
>>> rp.count(8)
1
También podemos indagar por la posición que ocupa en la secuencia un número. Por ejemplo, el número 4 se encuentra en la posición 2 de la secuencia (se comienza a contar desde cero):
>>> rp.index(4)
2
También podemos preguntarle a Python por el valor en una posición data:
>>> rp.__getitem__(3)
6
Y también puedo usar el operador corchete de posición:
>>> rp[3]
6
Como veremos más adelante en el capítulo de iteradores, el objeto range es un objeto iterable, lo que puede notar en la clase (ver arriba) por la existencia de la función __iter__( ) que puede ser utilizadA para recorrer uno a uno sus valores, y usar esos valores para distintos tipos de actividad.
>>> r=range(100)
Miremos cómo se compone la clase del tipo:
>>> dir(r)
['__bool__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index', 'start', 'step', 'stop']
Como se ve, existen tres atributos de la clase range. Usémoslos para aprender un poco más cómo funciona:
>>> r.start
0
>>> r.step
1
>>> r.stop
100
>>>
Tener un rango creado de la manera como se muestra en el ejemplo, significa tener 100 valores, comenzando desde 0, y hasta 100-1, esto es, hasta 99.
start. Es un número entero y es opcional. Si no se especifica asume como valor inicial se especifica automáticamente en 0 (cero).
stop. Es un número entero, y es obligatorio especificarlo; Python siempre resta uno al valor especificado.
step. Es un valor entero, y es opcional. Si no se especifica, el incremento es automáticamente establecido en el valor de 1. El incremento puede ser negativo. Si el incremento es negativo, debe ajustar los valores start y stop acorde al decremento.
Veamos un ejemplo en el que definamos explícitamente el valor inicial, el final, y un incremento distinto de 1, por ejemplo 2:
>>> rp=range(0,10,2)
>>> rp.start
0
>>> rp.stop
10
>>> rp.step
2
Este rango se compone de los valores 0, 2, 4, 6 y 8. Note que el 10 no está disponible en el rango, lo que puede verificar contando el número de veces que aparece. Como se mencionó antes, Python siempre resta 1 al valor dado como stop.
Para verificar si un dato existe o no, puede usar la función count.
>>> rp.count(10)
0
>>> rp.count(1)
0
>>> rp.count(2)
1
>>> rp.count(8)
1
También podemos indagar por la posición que ocupa en la secuencia un número. Por ejemplo, el número 4 se encuentra en la posición 2 de la secuencia (se comienza a contar desde cero):
>>> rp.index(4)
2
También podemos preguntarle a Python por el valor en una posición data:
>>> rp.__getitem__(3)
6
Y también puedo usar el operador corchete de posición:
>>> rp[3]
6
Como veremos más adelante en el capítulo de iteradores, el objeto range es un objeto iterable, lo que puede notar en la clase (ver arriba) por la existencia de la función __iter__( ) que puede ser utilizadA para recorrer uno a uno sus valores, y usar esos valores para distintos tipos de actividad.
SLICES
Un slice es una definición de tajada de una colección de elementos. Se parece a un range en que tiene una posición inicial, una final, y un incremento.
Sin embargo, el objeto slice no contiene una función __iter__( ) , lo que indica que no es un objeto iterable como range.
Tampoco tiene funciones de conteo como __count__( ), o funciones de consulta de posición de elementos con __index__, o extracción de elementos con __getitem__.
>>> dir(slice)
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'indices', 'start', 'step', 'stop']
>>>
El objeto slice es útil para extraer tajadas completas de cadenas de caracteres(strings), listas o tuplas. También puedes usar el objeto slice para extraer subrangos de un rango. Se trata meramente de una definición de tajada de colección de datos.
A continuación, se presentan algunas de las características del uso de slices en cadenas de caracteres. Sin embargo, pueden ser aplicadas de la misma forma en listas y tuplas.
El uso de la clase slice se puede hacer directamente con sus métodos. Sin embargo, su uso se simplifica a través del operador corchete [ ], en el que se puede especificar un valor de comienzo, un valor de fin, y un incremento, separando dichos valores con el operador dos puntos( : ).
[ : ] la tajada va desde la posición cero a la posición final de la colección.
>>>s='ABCDEFGHIJK'
>>>
>>>s[:]
'ABCDEFGHIJK'
>>>
[ start : end ] la tajada va entre las dos posiciones dadas. La última posición se resta 1.
>>> s[4:5] #se pide desde la posición 4 a la posición 4 (reste 1!)
'E'
>>> s[1:1]
''
>>> s[7:10]
'HIJ'
>>>
[ start:] lo mismo que la anterior, pero el último valor es la última posición.
>>> s[4:]
'EFGHIJK'
>>> s[1:]
'BCDEFGHIJK'
>>> s[7:]
'HIJK'
>>>
[:end] se comienza en la posición cero, y se va hasta la posición que indique como end -1.
>>> s[:4]
'ABCD'
>>> s[:1]
'A'
>>> s[:7]
'ABCDEFG'
>>>
Para cambiar el incremento por defecto de 1 a otro valor, usamos dos puntos ( : ) adicionales con el valor respectivo. Si usamos los dos puntos y no indicamos el valor, de nuevo se asume 1. Si el incremento no es 1, el recorrido sobre la colección va a ser el especificado. Siguen aplicando las mismas condiciones para start y end.
>>> s[::2]
'ACEGIK'
>>>
>>> s[::3]
'ADGJ'
>>>
Un incremento de -1 indica que la tajada se tomará de forma inversa. Si el incremento es negativo, debe ajustar los valores start y stop acorde al decremento. En el caso que no especifique los valores start y stop, se asume como comienzo el último elemento, y como final el primero elemento.
>>> s
'ABCDEFGHIJK'
>>> s[::-1]
'KJIHGFEDCBA'
>>> s[::-2]
'KIGECA'
>>> s[::-3]
'KHEB'
>>> s[::-4]
'KGC'
>>>
Sin embargo, el objeto slice no contiene una función __iter__( ) , lo que indica que no es un objeto iterable como range.
Tampoco tiene funciones de conteo como __count__( ), o funciones de consulta de posición de elementos con __index__, o extracción de elementos con __getitem__.
>>> dir(slice)
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'indices', 'start', 'step', 'stop']
>>>
El objeto slice es útil para extraer tajadas completas de cadenas de caracteres(strings), listas o tuplas. También puedes usar el objeto slice para extraer subrangos de un rango. Se trata meramente de una definición de tajada de colección de datos.
A continuación, se presentan algunas de las características del uso de slices en cadenas de caracteres. Sin embargo, pueden ser aplicadas de la misma forma en listas y tuplas.
El uso de la clase slice se puede hacer directamente con sus métodos. Sin embargo, su uso se simplifica a través del operador corchete [ ], en el que se puede especificar un valor de comienzo, un valor de fin, y un incremento, separando dichos valores con el operador dos puntos( : ).
[ : ] la tajada va desde la posición cero a la posición final de la colección.
>>>s='ABCDEFGHIJK'
>>>
>>>s[:]
'ABCDEFGHIJK'
>>>
[ start : end ] la tajada va entre las dos posiciones dadas. La última posición se resta 1.
>>> s[4:5] #se pide desde la posición 4 a la posición 4 (reste 1!)
'E'
>>> s[1:1]
''
>>> s[7:10]
'HIJ'
>>>
[ start:] lo mismo que la anterior, pero el último valor es la última posición.
>>> s[4:]
'EFGHIJK'
>>> s[1:]
'BCDEFGHIJK'
>>> s[7:]
'HIJK'
>>>
[:end] se comienza en la posición cero, y se va hasta la posición que indique como end -1.
>>> s[:4]
'ABCD'
>>> s[:1]
'A'
>>> s[:7]
'ABCDEFG'
>>>
Para cambiar el incremento por defecto de 1 a otro valor, usamos dos puntos ( : ) adicionales con el valor respectivo. Si usamos los dos puntos y no indicamos el valor, de nuevo se asume 1. Si el incremento no es 1, el recorrido sobre la colección va a ser el especificado. Siguen aplicando las mismas condiciones para start y end.
>>> s[::2]
'ACEGIK'
>>>
>>> s[::3]
'ADGJ'
>>>
Un incremento de -1 indica que la tajada se tomará de forma inversa. Si el incremento es negativo, debe ajustar los valores start y stop acorde al decremento. En el caso que no especifique los valores start y stop, se asume como comienzo el último elemento, y como final el primero elemento.
>>> s
'ABCDEFGHIJK'
>>> s[::-1]
'KJIHGFEDCBA'
>>> s[::-2]
'KIGECA'
>>> s[::-3]
'KHEB'
>>> s[::-4]
'KGC'
>>>
SESIÓN #4 DE EJERCITACIÓN: EXPRESIONES PYTHON EN LA CONSOLA
- Use Python para verificar los valores obtenidos en los puntos de la práctica de pseudocódigo para expresiones.
- Si usted trabajó los problemas de pseudocódigo del taller de expresiones, y también hizo las expresión en Python en el literal anterior¿En qué puntos encuentra discordancias entre la forma de trabajar en pseudocódigo y la forma de trabajo de los operadores en Python? ¿Qué explicación tiene para esas discordancias?
- Construya expresiones Python para genera dos números aleatorios gaussianos, y determine la distancia numérica entre ellos. Para generar un número aleatorio gaussiano, use la fórmula de Box-Muller, r = sin(2 p v)(-2 ln u)1/2, donde v y u son números aleatorios entre 0 y 1. Para generar números aleatorios en Python entre 0 y 1, use la librería random usando import random al principio de su programa: un número aleatorio entre 0 y 1 lo genera con random.random(). (Sedgewick et al., 2015, p.53)
- Construya expresiones Python para convertir un punto de coordenadas (x,y) a coordenadas polares (r, q). Primero asigne valores a dos variables x,y. Importe la librería math, y calcule math.atan2(y, x), que computa el valor arcotangente de y/x, y que está en el rango -p a p. Finalmente encuentre r, a partir del teorema de Pitágoras.
(Sedgewick et al., 2015, p.53) - Construya la siguiente expresión usando solo métodos de objeto y ejecútela para conocer el resultado. Luego compárelo con el resultado que le daría si usara la expresión directamente. Si no le dio igual, analice el porqué.
2 – 6 / 3 + 3 * 2 – 4 / 2 - Construya la siguiente expresión en su equivalente Python y calcúlela. Luego haga lo mismo usando solo métodos de objetos, y calcúlela. Tenga en cuenta que el operador not no se encuentra disponible como método a partir de la versión 3+ de Python, y solo están disponibles los métodos __and__, __or__, __rand__, __ror__.
.t. ⊕ ¬.f. and ¬¬.f. - Construya la cadena “¡Si!” a partir de los códigos de los caracteres individuales.
- Extraiga de la cadena “1234567890” el primer caracter y el último.
- Extraiga el caracter‘6’de la cadena “1234567890”.
- Extraiga el tipo de dato del caracter‘5’de la cadena “1234567890”.
- A partir de la cadena “5”, obtenga la cadena “5555555555”.
- Dado el objeto range(-18909,23756,133), determine cuál es el valor en la posición 20.
- Dado el objeto range(-19907,38751,129), determine si el valor 37 se encuentra disponible.
- Use un slice para extraer de la cadena “ABCDE”la secuencia “ABC”.
- Use un slice para extraer de la cadena “ABCDE”la cadena “EDCBA”.
- Use un slice para extraer de la cadena “ABCDE”la cadena “EA”.
- Use un slice para extraer de la cadena “ABCDE”la cadena “EB”.
- Asigne dos valores de cadena cualquiera a dos variables. Use dunders para determinar la longitud de las variables.
- Asigne strings a dos variables, y compare si las cadenas son iguales, usando el dunders.
- Asigne strings a dos variables, y sume la longitud de las cadenas usando solo dunders.
- Asigne strings a dos variables y pregunte si la longitud de una de las cadenas es menor a la longitud de la otra, todo usando solo dunders.
- Asigne strings a dos variables, y pregunte si las cadenas son diferentes usando dunders.
- Asigne un valor string a una variable, y extraiga algún carácter usando una función dunder.
- Asigne un valor string a una variable, y extraiga algún carácter usando corchetes.
- Cree una string cualquiera, y pregunte, usando alguno de los métodos, si la cadena está compuesta sólo por caracteres en minúscula, o sólo por caracteres en mayúscula.
- Cree una string cualquiera, y pregunte, usando alguno de los métodos, si la cadena está compuesta sólo por caracteres en minúscula, o sólo por caracteres en mayúscula.
- Cree una string cualquiera, y pregunte, usando alguno de los métodos, si la cadena está compuesta sólo por letras.
- Cree una string cualquiera, y pregunte, usando alguno de los métodos, si la cadena está compuesta sólo por dígitos.
- Cree una string cualquiera que contiene letras en mayúscula y en minúscula. Luego usando alguno de los métodos de la cadena, pase todos los caracteres a mayúscula.
- Cree una string cualquiera que contiene letras en mayúscula y en minúscula. Luego usando alguno de los métodos de la cadena, pase todos los caracteres a minúscula.
- Cree una string cualquiera que contiene letras en mayúscula y en minúscula. Luego usando alguno de los métodos de la cadena, pregunte si todos los dígitos están en minúscula. Luego ajuste el contenido de la cadena para que el resultado sea True.
- Cree una string cualquiera que contiene letras en mayúscula y en minúscula. Luego usando alguno de los métodos de la cadena, pase sólo el primer caracter a mayuscula, y el resto que quede en minúscula.
- Cree una string cualquiera con las letras como las desee. Luego pregunte si todas las letras son mayúsculas, o si todas las letras son minúsculas. Para aplicar el operador OR, use un dunder.
- Cree dos string cualquiera con las letras como las desee. Luego pregunte si todas las letras son mayúsculas en ambas, o si todas las letras son minúsculas en ambas. Para aplicar el operador OR, use un dunder.
- Cree dos string cualquiera con las letras como las desee. Luego pregunte si una de las cadenas es toda minúscula, y la otra toda mayúscula. Ajuste los contenidos de las cadenas para obtener el valor True sin importar el orden del uso de las dos cadenas.
- Cree una cadena con un texto. Luego cree otra cadena con otro texto. Use los métodos de las cadenas para determinar si el texto de una cadena está dentro del texto la otra. Ajuste el contenido de las cadenas para que el resultado sea True.
- Cree una cadena con un texto. Use los métodos de las cadenas para determinar la posición específica de un carácter.
- Cree una cadena con un texto. Use los métodos de las cadenas para determinar la posición específica de la segunda ocurrencia de un caracter.
- Cree una cadena con un texto. Use los métodos de las cadenas para determinar la posición específica de la primera ocurrencia de un carácter desde la derecha.
- Cree una cadena con un texto. Use los métodos de las cadenas para determinar la posición específica de la segunda ocurrencia de un carácter desde la derecha.
- Cree una cadena con un texto. Use los métodos de las cadenas para determinar si la cadena contiene letras, o números, o una combinación de ellas. Si contiene algo distinto a letras o números, emite False.
- Se cuenta con una cadena genética. Cada 3 caracteres representan un aminoácido, y a eso se le denomina codón. Construya una expresión Python que le permita determinar cuántos codones hay presentes.
- Se cuenta con una cadena genética. Cada 3 caracteres representan un aminoácido, y a eso se le denomina codón. Construya una expresión Python que le permita extraer la secuencia de un codón especifico. Por ejemplo, en la cadena “AAGGTACCCTAGGTA”, el codón 4 es “TAG”.
- La terminación de un gen en una secuencia de nucleótidos se da con una secuencia de tres aminoácidos conocida como codón de parada. Los posibles codones de parada son “UAA”, “UAG” y “UGA”. Construya una expresión que le permita determinar si la secuencia genética termina en un codón de parada.
- La terminación de un gen en una secuencia de nucleótidos se da con una secuencia de tres aminoácidos conocida como codón de parada. Los posibles codones de parada son “UAA”, “UAG” y “UGA”. Construya una expresión que le permita determinar si alguno de los codones de parada está presente en la cadena.
FUNCIONES EN PYTHON
En Python, todas las operaciones sobre objetos son funciones o son métodos de un objeto.
Los métodos de un objeto son simplemente funciones, pero pertenecen a alguna clase, por lo que forman parte del dominio de los objetos. No existe ninguna función en python que no pertenezca a algún objeto o clase.
En esta sección aprenderemos a escribir la función más básica posible en Python, para tener a la mano las características que necesitamos para ejemplos posteriores. No estaremos revisando temas especiales sobre parámetros, o argumentos. Eso vendrá en capítulos posteriores.
CREACIÓN DE FUNCIONES EN PYTHON.
Para definir una función con nombre en Python, tenemos una única forma, y es con la palabra def. Esta palabra reemplaza todas las que conocemos en nuestros pseudocódigos como fx, fn, fun, func o function.
Luego de a palabra def viene el nombre de la función, y, a continuación del nombre, sigue la lista de parámetros entre paréntesis, de la misma forma en que lo hacemos en nuestros pseudocódigos.
Ta pronto termine la lista de parámetros entre paréntesis, se requiere poner el caracter dos puntos( ‘:’ ) , llamado ‘colon’ en inglés.
Para el cuerpo, es clave que haya una indentación, y que las líneas subsiguientes a la primera línea indentada estén al mismo nivel de indentación. Cuando quiero que una función no haga nada, uso la palabra pass, que significa que no haga nada (‘paso!’).
>>> def double( ):
... pass
Una llamada a la función se logra con solo nombrar la función y poner paréntesis al lado del nombre.
>>> double()
>>>
Cuando la función no devuelve valor, Python asume que el valor a devolver es el valor None. El valor None en Python significa eso: no valor. Este valor no es presentado en la consola REPL de Python.
Cuando no se especifican los paréntesis, Python no llama la función, pero indica el tipo del objeto. En el caso de un objeto función, lo que hace es entregar la dirección hexadecimal en la que se encuentra en memoria.
>>> double
<function double at 0x106b78b80>
Una función también es un objeto, y, como ya es costumbre, es bueno conocer un poco sobre el objeto. Dado que una función en Python es un objeto, puedo almacenarla y usarla como si se tratara de algún otro valor.
Podemos verificar el tipo de una función con la función type( ):
>>> type(double)
<class 'function'>
La función dir( ) entrega una lista Python que describe el objeto.
Esta función ya la hemos usado antes:
>>> dir (double)
['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
>>>
Por el momento, dejemos a un lado este maravilloso hecho sobre el objeto function de Python, y hagamos que la función haga algo.
>>> def double(x):
... return x+x
...
Del conocimiento que tenemos de nuestros pseudocódigos, vemos que la función recibe un parámetro, y ese parámetro lo usamos para determinar el doble del valor.
Note que usamos la palabra return para devolver el valor. No hay otra palabra para devolver el valor en este tipo de funciones, y si no se usa la palabra return, la función evaluará la expresión, pero, al momento de la llamada, no devolverá ningún valor.
En este caso, la función recibe un parámetro, y lo usa para calcular el doble del parámetro.
>>> double(8)
16
ANOTACIONES EN PARÁMETROS Y VALOR DE RETORNO.
Los parámetros y el valor de retorno en Python pueden ser anotados.
Esto es, podemos asociar información adicional al parámetro.
Las anotaciones son expresiones que se evalúan, y el valor de la evaluación acompaña al parámetro. Es, de algún modo, un mecanismo para generar data de forma dinámica sobre el parámetro.
Esta información puede ser consultada más adelante por alguna otra herramienta, o por la misma función.
Por ejemplo, supongamos que quiero simplemente aclarar el tipo del parámetro. Podríamos usar una expresión válida, incluyendo un tipo de dato.
>>> def double(x:float):
... return x+x
...
>>> double(32)
64
>>>
Las anotaciones pueden aludir cualquier tipo de información. Incluso podrían cargar objetos completos. Se debe tener en cuenta que las anotaciones no son tenidas en cuenta por el traductor de Python en cuento al tipo de dato del parámetro.
Otra anotación interesante en Python se puede agregar al final de la declaración de la función, y antes de los dos puntos, usando la combinación de caracteres guión y mayor (->). Esta anotación pretende documentar o anotar el valor de retorno de la función.
>>> def suma(x:float, y:float)->float:
... return x+x
...
>>>
Note que ya se establecieron 3 anotaciones: una por cada parámetro, y uno para el valor de retorno de la función. Ahora supongamos que queremos consultar dicha información.
Dado que la función es un objeto, podemos usar el atributo __annotations__ del objeto:
>>> suma.__annotations__
{'x': <class 'float'>, 'y': <class 'float'>, 'return': <class 'float'>}
>>>
Como puede ver, el atributo __annotations__ es un diccionario, donde las claves son el nombre de los parámetros, y los valores asociados a cada parámetro es la evaluación de las anotaciones. En cuanto a la anotación de retorno, la clave se convierte en ‘return‘.
Podría decirse entonces, para resumir, que las anotaciones son una forma de entregar datos de interés asociados a parámetros, y, si se desea, al valor de retorno de la función. Muchos usos pueden dársele a esta característica del lenguaje que pueden ser utilizados por distintas utilidades de software, como por ejemplo autocompletación de código, pruebas automáticas, documentación, etc.
SANGRADO(INDENTADO) DE BLOQUES DE CÓDIGO EN PYTHON.
En el taller que sigue, usted comenzará a hacer sus primeras funciones en Python. Para programar una solución a un problema, lo más recomendable es usar un editor, donde sea posible escribir el código, y se pueda correr luego.
El código de una función deberá quedar con indentación. Esto es, el código interno de la función debe quedar algunos caracteres más adelante que la columna en la que comenzó la definición con def, no importa cuantos.
Debe tener en cuenta que la indentación en Python es estricto dentro de un mismo bloque. Lea bien los errores que se le presenten para guiarse bien hacia la solución.
Ejemplo
Escriba una función en Python que halle la raíz cuadrada de la suma de dos números.
def raizDeSuma(a, b):
raiz = ( a + b ) ** 0.5
return raiz
print(raizDeSuma(8,9))
Para probar la función, puede usar una llamada que puede ubicar por fuera de la función. Para visualizar valores, debe usar la función print.
También tenga en cuenta que los resultados aparecen en la consola, y no en el editor.
Ejemplo
Escriba una función en python que reciba dos puntos como pares de coordenadas (x,y), y determine si están en el mismo cuadrante del plano cartesiano.
def mismocuadrante( x1, y1, x2, y2):
return x1 * x2 > 0 ∧ y1 * y2 > 0
print(mismocuadrante(8,9))
En este caso, podemos usar los signos de los valores. El signo de x1 y x2 debe ser el mismo, por lo que al multiplicarlos siempre debe ser > 0, y se hace lo mismo con los valores de y1 y y2.
FUNCIONES LAMBDA (ANÓNIMAS) EN PYTHON.
En Python es posible crear funciones anónimas, también llamadas lambda.
Como ya se discutió en las funciones lambda en pseudocódigo, una función lambda no necesita un nombre, y simplemente se convierte en un valor.
Para definir una función Python lambda, se deberá usar la palabra lambda seguida de los parámetros. Al igual que cualquier otra función, se identifica el comienzo del bloque de código con dos puntos ( : ).
>>> f = lambda x , y : x * y
Una función lambda se usa para definir funciones expresión, y no es posible hacer bloques de código completos como en las funciones bloque Python, a menos que la función lambda delegue la expresión o parte de ella a funciones bloque Python.
En el ejemplo, la variable f contiene la función lambda de multiplicar dos números.
>>> f
<function <lambda> at 0x7fc567969940>
>>> type(f)
<class 'function'>
>>>
También podemos revisar el objeto, y ver que contiene los mismos atributos que una función tradicional:
>>> dir(f)
['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
Dado que la variable f referencia una función lambda, puede llamarla usando la variable f. Si más de una variable referencia la misma función, cualquiera de ellas puede usarse para la llamada.
>>> g=f
>>> h=g
>>> f(2,3)
6
>>> g(2,3)
6
>>> h(2,3)
6
Una variable no es la única que puede referenciar lambdas. Por ejemplo, podríamos tener una lista en Python que contenga lambdas, y las llamadas a las funciones se harían haciendo referencia a alguna de las posiciones:
>>> f = [lambda x,y: x+y, lambda x,y: x-y, lambda x,y: x*y]
>>> f[0](9,2)
11
>>> f[1](9,2)
7
>>> f[2](9,2)
18
>>>
Incluso, si se conoce la ubicación en memoria de la función, se puede usar para invocar la función:
>>> g=id(f)
>>> import ctypes
>>> (ctypes.cast(0x7fd258735050, ctypes.py_object).value)(3,7)
21
Los métodos de un objeto son simplemente funciones, pero pertenecen a alguna clase, por lo que forman parte del dominio de los objetos. No existe ninguna función en python que no pertenezca a algún objeto o clase.
En esta sección aprenderemos a escribir la función más básica posible en Python, para tener a la mano las características que necesitamos para ejemplos posteriores. No estaremos revisando temas especiales sobre parámetros, o argumentos. Eso vendrá en capítulos posteriores.
CREACIÓN DE FUNCIONES EN PYTHON.
Para definir una función con nombre en Python, tenemos una única forma, y es con la palabra def. Esta palabra reemplaza todas las que conocemos en nuestros pseudocódigos como fx, fn, fun, func o function.
Luego de a palabra def viene el nombre de la función, y, a continuación del nombre, sigue la lista de parámetros entre paréntesis, de la misma forma en que lo hacemos en nuestros pseudocódigos.
Ta pronto termine la lista de parámetros entre paréntesis, se requiere poner el caracter dos puntos( ‘:’ ) , llamado ‘colon’ en inglés.
Para el cuerpo, es clave que haya una indentación, y que las líneas subsiguientes a la primera línea indentada estén al mismo nivel de indentación. Cuando quiero que una función no haga nada, uso la palabra pass, que significa que no haga nada (‘paso!’).
>>> def double( ):
... pass
Una llamada a la función se logra con solo nombrar la función y poner paréntesis al lado del nombre.
>>> double()
>>>
Cuando la función no devuelve valor, Python asume que el valor a devolver es el valor None. El valor None en Python significa eso: no valor. Este valor no es presentado en la consola REPL de Python.
Cuando no se especifican los paréntesis, Python no llama la función, pero indica el tipo del objeto. En el caso de un objeto función, lo que hace es entregar la dirección hexadecimal en la que se encuentra en memoria.
>>> double
<function double at 0x106b78b80>
Una función también es un objeto, y, como ya es costumbre, es bueno conocer un poco sobre el objeto. Dado que una función en Python es un objeto, puedo almacenarla y usarla como si se tratara de algún otro valor.
Podemos verificar el tipo de una función con la función type( ):
>>> type(double)
<class 'function'>
La función dir( ) entrega una lista Python que describe el objeto.
Esta función ya la hemos usado antes:
>>> dir (double)
['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
>>>
Por el momento, dejemos a un lado este maravilloso hecho sobre el objeto function de Python, y hagamos que la función haga algo.
>>> def double(x):
... return x+x
...
Del conocimiento que tenemos de nuestros pseudocódigos, vemos que la función recibe un parámetro, y ese parámetro lo usamos para determinar el doble del valor.
Note que usamos la palabra return para devolver el valor. No hay otra palabra para devolver el valor en este tipo de funciones, y si no se usa la palabra return, la función evaluará la expresión, pero, al momento de la llamada, no devolverá ningún valor.
En este caso, la función recibe un parámetro, y lo usa para calcular el doble del parámetro.
>>> double(8)
16
ANOTACIONES EN PARÁMETROS Y VALOR DE RETORNO.
Los parámetros y el valor de retorno en Python pueden ser anotados.
Esto es, podemos asociar información adicional al parámetro.
Las anotaciones son expresiones que se evalúan, y el valor de la evaluación acompaña al parámetro. Es, de algún modo, un mecanismo para generar data de forma dinámica sobre el parámetro.
Esta información puede ser consultada más adelante por alguna otra herramienta, o por la misma función.
Por ejemplo, supongamos que quiero simplemente aclarar el tipo del parámetro. Podríamos usar una expresión válida, incluyendo un tipo de dato.
>>> def double(x:float):
... return x+x
...
>>> double(32)
64
>>>
Las anotaciones pueden aludir cualquier tipo de información. Incluso podrían cargar objetos completos. Se debe tener en cuenta que las anotaciones no son tenidas en cuenta por el traductor de Python en cuento al tipo de dato del parámetro.
Otra anotación interesante en Python se puede agregar al final de la declaración de la función, y antes de los dos puntos, usando la combinación de caracteres guión y mayor (->). Esta anotación pretende documentar o anotar el valor de retorno de la función.
>>> def suma(x:float, y:float)->float:
... return x+x
...
>>>
Note que ya se establecieron 3 anotaciones: una por cada parámetro, y uno para el valor de retorno de la función. Ahora supongamos que queremos consultar dicha información.
Dado que la función es un objeto, podemos usar el atributo __annotations__ del objeto:
>>> suma.__annotations__
{'x': <class 'float'>, 'y': <class 'float'>, 'return': <class 'float'>}
>>>
Como puede ver, el atributo __annotations__ es un diccionario, donde las claves son el nombre de los parámetros, y los valores asociados a cada parámetro es la evaluación de las anotaciones. En cuanto a la anotación de retorno, la clave se convierte en ‘return‘.
Podría decirse entonces, para resumir, que las anotaciones son una forma de entregar datos de interés asociados a parámetros, y, si se desea, al valor de retorno de la función. Muchos usos pueden dársele a esta característica del lenguaje que pueden ser utilizados por distintas utilidades de software, como por ejemplo autocompletación de código, pruebas automáticas, documentación, etc.
SANGRADO(INDENTADO) DE BLOQUES DE CÓDIGO EN PYTHON.
En el taller que sigue, usted comenzará a hacer sus primeras funciones en Python. Para programar una solución a un problema, lo más recomendable es usar un editor, donde sea posible escribir el código, y se pueda correr luego.
El código de una función deberá quedar con indentación. Esto es, el código interno de la función debe quedar algunos caracteres más adelante que la columna en la que comenzó la definición con def, no importa cuantos.
Debe tener en cuenta que la indentación en Python es estricto dentro de un mismo bloque. Lea bien los errores que se le presenten para guiarse bien hacia la solución.
Ejemplo
Escriba una función en Python que halle la raíz cuadrada de la suma de dos números.
def raizDeSuma(a, b):
raiz = ( a + b ) ** 0.5
return raiz
print(raizDeSuma(8,9))
Para probar la función, puede usar una llamada que puede ubicar por fuera de la función. Para visualizar valores, debe usar la función print.
También tenga en cuenta que los resultados aparecen en la consola, y no en el editor.
Ejemplo
Escriba una función en python que reciba dos puntos como pares de coordenadas (x,y), y determine si están en el mismo cuadrante del plano cartesiano.
def mismocuadrante( x1, y1, x2, y2):
return x1 * x2 > 0 ∧ y1 * y2 > 0
print(mismocuadrante(8,9))
En este caso, podemos usar los signos de los valores. El signo de x1 y x2 debe ser el mismo, por lo que al multiplicarlos siempre debe ser > 0, y se hace lo mismo con los valores de y1 y y2.
FUNCIONES LAMBDA (ANÓNIMAS) EN PYTHON.
En Python es posible crear funciones anónimas, también llamadas lambda.
Como ya se discutió en las funciones lambda en pseudocódigo, una función lambda no necesita un nombre, y simplemente se convierte en un valor.
Para definir una función Python lambda, se deberá usar la palabra lambda seguida de los parámetros. Al igual que cualquier otra función, se identifica el comienzo del bloque de código con dos puntos ( : ).
>>> f = lambda x , y : x * y
Una función lambda se usa para definir funciones expresión, y no es posible hacer bloques de código completos como en las funciones bloque Python, a menos que la función lambda delegue la expresión o parte de ella a funciones bloque Python.
En el ejemplo, la variable f contiene la función lambda de multiplicar dos números.
>>> f
<function <lambda> at 0x7fc567969940>
>>> type(f)
<class 'function'>
>>>
También podemos revisar el objeto, y ver que contiene los mismos atributos que una función tradicional:
>>> dir(f)
['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
Dado que la variable f referencia una función lambda, puede llamarla usando la variable f. Si más de una variable referencia la misma función, cualquiera de ellas puede usarse para la llamada.
>>> g=f
>>> h=g
>>> f(2,3)
6
>>> g(2,3)
6
>>> h(2,3)
6
Una variable no es la única que puede referenciar lambdas. Por ejemplo, podríamos tener una lista en Python que contenga lambdas, y las llamadas a las funciones se harían haciendo referencia a alguna de las posiciones:
>>> f = [lambda x,y: x+y, lambda x,y: x-y, lambda x,y: x*y]
>>> f[0](9,2)
11
>>> f[1](9,2)
7
>>> f[2](9,2)
18
>>>
Incluso, si se conoce la ubicación en memoria de la función, se puede usar para invocar la función:
>>> g=id(f)
>>> import ctypes
>>> (ctypes.cast(0x7fd258735050, ctypes.py_object).value)(3,7)
21
SESIÓN #5 DE EJERCITACIÓN:
PRIMERAS MICROFUNCIONES BÁSICAS (CONSOLA O EDITOR)
- Use la consola de Python, y cree una función que reciba un número, y devuelva el número convertido en cadena. Llame la función para verificar que quedó bien construida. Consulte las anotaciones de la función usando el atributo __annotations__ de la función.
- Use la consola de Python y cree una función que halle el producto de dos números. Agréguele una anotación al primer parámetro. Llame la función para ver que todo ande bien. Revise las anotaciones de a función usando el atributo __annotations__ de la función.
- Sumar primeros n números naturales.
Suponga, que usted no sabe nada sobre ciclos o llamadas recursivas en programación. Algunas veces se requiere sumar n números naturales, por lo que algunas veces, la primera aproximación de algunos desarrolladores es hacer un ciclo, tema que no se ha analizado aún y que veremos más adelante.
Pero, en realidad, no es necesario un ciclo, si lo que se requiere es sumar números enteros entre 1 y un número n cualquiera dado. Para lograrlo, sólo necesita conocer n. Lo que debe hacer es multiplicar n por la cantidad n + 1 y a ese resultado dividirlo por 2. ¡Y ya tiene su sumatoria, resuelta sin sumatorias!
Construya una función Python llamada sum_1_to_N(), que halle la sumatoria de los n primeros números naturales, dado n como parámetro, y verifique la afirmación.
Use anotaciones de tipo tanto en el parámetro, como en el tipo de salida de la función. - Suma de n impares.
Otras veces, queremos sumar los primeros n números impares. Se puede hacer un ciclo, pero no lo necesitamos. El truco es que ¡n elevado al cuadrado suma los cubos entre 1 y n!
Construya una función Python llamada sum_impares_1_to_N(), que halle la sumatoria de los primeros n impares, n dado como parámetro, y verifique la afirmación.
Use anotaciones de tipo tanto en el parámetro, como en el tipo de salida de la función. - Suma de cuadrados sin usar bucles.
Para hallar la suma de los cuadrados de los primeros n números sin usar ciclos, se puede tomar a n, multiplicarlo por n + 1, y al resultado multiplicarlo por 2n + 1. Si al resultado final lo divide por 6, obtendrá la suma de los primero cuadrados hasta n al cuadrado.(Zwillinger, 2018, p.19).
Construya una función Python que determine la suma de los cuadrados de los primeros n números naturales. - Suma de cubos sin usar bucles.
Para hallar la suma de los cubos de los primeros n números sin usar ciclos, se puede tomar el cuadrado de n, multiplicarlo por el cuadrado de n + 1, y al resultado dividirlo por 4. (Zwillinger, 2018, p.19).
Construya una función Python que determine la suma de los cubos de los primeros n números naturales. - Suma de cuartas potencias sin usar ciclos.
Para hallar la suma de las cuartas potencias de los primeros n números sin usar ciclos, se puede usar la fórmula(Zwillinger, 2018, p.19).
Construya una función Python que determine la suma de las cuartas potencias de los primeros n números naturales. - Multiplicación Babilónica.
Los babilonios tenían una forma interesante para multiplicar dos números. Si querían multiplicar dos números a y b, calculaban primero la suma de a y b, y luego calculaban la resta de a y b. Esas dos cantidades la elevaban al cuadrado usando unas tablas que ya tenían pre-calculadas. Luego restaban esos dos cuadrados y dividían por 4, para finalmente obtener el valor de la multiplicación.
(Posamentier, Lehmann, 2014, pag 76).
Elabore una función Python que reciba dos parámetros a y b, halle la multiplicación babilónica. Haga pruebas llamando la función con distintos valores para los argumentos a y b. - Invertir dos números.
Construya una función en Python que reciba una tupla de dos números, y devuelva una tupla con los números invertidos. - Sort de tres.
Construya una función Python Sort3() que, dada una tupla de tres números, devuelva otra tupla con los números ordenados. - Manguera Giratoria.
Una manguera giratoria tiene capacidad de riego de hasta un radio r dado. Si se pueden instalar de forma fija en un terreno N mangueras a lo ancho y M mangueras a lo largo, de tal modo que los círculos subtendidos no se superponen, pero sí se tocan tangencialmente. ¿Cuánta área quedará sin riego directo?
Use una función de apoyo para el área de un círculo, y otra función de apoyo para el área de un rectángulo. Use una función principal que hace el trabajo, y dele como nombre CalcularAreaSinRiegoDirecto(). - Media aritmética.
Escriba una función lambda Python para la media aritmética de cuatro números, que se define como la suma de los dos números dividida entre 4. - Media geométrica.
Escriba una función lambda Python para la media geométrica de 4 números, que se define como la raíz cuarta del producto de los dos números. - Media armónica. Escriba una función lambda Python para la media armónica de dos números, que se define como el doble del producto de los dos números dividida su suma.
- Inversiones.
Dado un capital C, un número de períodos n, y un interés i, se puede determinar el valor futuro de capital F, según la relación F=C(1+i)n. Construya una función Python que le permita calcular el valor futuro de cualquier inversión, y que se llama futurevalue(). La función deberá estar anotada con tipos. - Valores futuros.
Construya una función Python que se llama statfuturevalues() y que recibe 2 valores de capital X y Y, un interés y un número de períodos, y determine el valor futuro de cada uno de los capitales X y Y. Dado un capital, un número de períodos n, y un interés i, se puede determinar el valor futuro de capital F, según la relación F=C(1+i)n. Conocidos los dos valores furusos X, Y, determine la media geométrica, la media armónica, y la media aritmética de las dos inversiones en el futuro. Los valores se deberán devolver como tupla, y la función deberá estar anotada con tipos. - Circunscrito.
Construya una función lambda Python circumscribeany que, dados el área de un círculo y el área de un cuadrado, determine si el cuadrado puede ser inscrito en el círculo, o si el círculo puede ser inscrito en el cuadrado. - Divisible por dígito.
Construya una función lambda Python que, dado un número n de tres cifras y un dígito d, determine si alguno de los tres dígitos del número n es divisible por el dígito d dado. - Bisiesto. Construya una función lambda Python que determine si un año dado es bisiesto. Un año es bisiesto si es divisible por 4 o por 400, pero no por 100. Por ejemplo, los años 1700, 1800 y 1900 no son bisiestos. Pero los años 1600, 2000 y 2400 sí lo son.
- Mismo cuadrante.
Función Python que reciba dos puntos como pares de coordenadas (x,y), y determine si están en el mismo cuadrante del plano cartesiano. No puede usar la sentencia if en este ejercicio. - Rango. Python cuenta con un secuenciador range, que permite genera números desde un valor inicial, hasta un valor final, usando incrementos de cualquier naturaleza. Construya una función lambda Python llamada rango, que le permita generar un número 'iésimo' de la secuencia, dados el valor inicial, el valor final, el incremento, y el índice del valor que desea extraer. No use la función range() de Python, pues lo que se quiere es que cree su propia función.
Por ejemplo,
para rango(0,100,1,1), el valor es 0.
para rango(5,100,5,4), el valor es 25.
para rango(237,487575663556,115,4), el valor es 697.
para rango(237,3000000,115,67), el valor es 7942.
para rango(23,2000000,1270,6), el valor es 7643. - Atleta decidido. Un atleta decide que durante las h horas máximo que dura una carrera de k kilómetros, la primera hora recorrerá n kilómetros, y descansará hasta que comience la segunda hora. De la segunda hora en adelante correrá a un ritmo de r kilómetros por hora. Escriba una función Python que determine para valores h, k, n, y r dados como parámetros, si llegará o no a la meta a tiempo. Tenga en cuenta que una carrera siempre dura como mínimo 1 hora.
- Gran Círculo. Escriba una función Python denominada grancírculo(), que recibe dos tuplas dadas como parámetros, cada una con dos 2 puntos coordenados (x1, y1) y (x2, y2), donde cada punto representa una posición geográfica sobre la tierra (latitud , longitud), dados en grados, y la función devuelve la distancia del gran círculo entre los dos puntos, en kilómetros. El cálculo se prepara con siguiente ecuación:
d = 111 arccos(sin(x1)sin(x2) + cos(x1)cos(x2)cos(y1 – y2))
Dado que en Python las funciones trigonométricas trabajan en radianes, haga dos funciones lambda, una que cambie grados a radianes (grados*pi/180) para convertir las variables de entrada a radianes, y otra que convierta radianes a grados (radianes*180/pi) para convertir el resultado final d que da en radianes, a grados.
La constante pi, tiene su equivalente en Python como math.pi.
Las funciones seno y coseno, están en la librería math como sin() y cos().
Compruebe si su código quedó bien hecho, calculando la distancia entre Paris (+48.87°N , -2.33° W) y San Francisco (37.8° N , 122.4° W), que es de 8701.389 kilómetros. (Sedgewick & Wayne, 2017)
INTERACCIÓN CON EL USUARIO
En los viejos tiempos de la computación, los sistemas operativos no contaban con interfaz gráfica. Ya sea que fuera Unix o Ms DOS el sistema operativo de moda, la interfaz gráfica siempre era una consola.
Estas consolas han perdurado en el tiempo, y se mantienen hoy vigentes en sistemas operativos como Windows, macOS, y linux.
En todos los sistemas operativos en los que se trabaje con una interfaz gráfica, siempre habrá una consola del sistema en la cual puedes correr comandos.
Cada que corres un programa en Python, la interacción se hace directamente en una consola. Sin embargo, existen muchas librerías que te permiten capturar y presentar datos en una interfaz gráfica. De hecho, Python trae una librería estándar para hacerlo, que es el defacto para la construcción de interfaz gráfica con python: la librería se llama Tkinter.
En esta sessión conoceremos la forma más básica de interactuar con el usuario a través e la consola.
CONSOLA PYTHON Y LA FUNCIÓN print() SIN FORMATO
La función de ayuda print() de Python permite presentar datos en pantalla.
En esta sección nos apropiaremos de su forma más básica: imprimir datos sin formato en consola, lo que nos permitirá poder interactuar con el usuario de forma inmediata.
print( ).
Nos permite enviar un salto de línea a la pantalla.
El comportamiento de la función print( ) es que, luego que se ejecuta, manda un salto de línea. En este caso y si no hay datos, siempre mandará el salto.
El caracter específico que la función envía es caracter de control de código 10, y que se puede representar como '\n'.
Para imprimir varios saltos de línea, usamos varias llamadas a la función print().
>>> print()
>>>
>>> print();print();print()
>>>
print(dato,… ).
Nos permite enviar datos, incluyendo un salto de línea al final. Debido a que print siempre salta al final, cualquier print( ) subsiguiente comenzará en la línea siguiente.
Python puede imprimir cualquier tipo de dato. La forma en que lo hace cuando no se especifica un formato va a depender del objeto que se imprima.
La coma tiene como función separar cada uno de los datos, para lo cual, siempre adiciona un único espacio, correspondiente al código decimal 32. Al final, siempre va el salto de línea
>>> print(1,2,3, 'A', 'B', 'C', "hello", "hola")
1 2 3 A B C hello hola
>>>
En realidad lo que print imprime es lo que le diga que imprima el objeto llamando el método __str__( ) del objeto concreto, que traen un comportamiento por defecto. Si embargo, se puede modificar este comportamiento.
Si quisiéramos partir las líneas en que se imprimen los datos, podríamos hacer las agrupaciones que gustemos.
>>> print(1,2,3, 'A', 'B', 'C')
1 2 3 A B C
>>> print("hello", "hola")
hello hola
>>>
También podemos usar el character de salto de línea en la posición que se desee.
Esto es, en una sola línea de salida podemos controlar los saltos en las posiciones que deseemos.
>>> print(1,2,3, '\n', 'A', 'B', 'C', '\n', '\n', "hello", "hola")
1 2 3
A B C
hello hola
>>>
Queda a su imaginación entender la teoría dada, y darse cuenta porqué a partir de la segunda línea de salida del ejemplo, se da un espacio antes de comenzar a presenter los datos.
Por ultimo, si desea suprimir el salto, puede reemplazarlo con la sentencia end, que es un parámetro de print, que permite especificar una cadena con la que se quera reemplazazar el salto.
Por ejemplo, para suprimir el salto, puedo especificar una cadena vacía, o un character concreto.
>>> print('A',end='');print('B',end='');print('C',end='');print('D',end='')
ABCD>>>
>>> print('A',end='@');print('B',end='@');print('C',end='@');print('D',end='@')
A@B@C@D@>>>
Al haber suprimido todos los saltos, todas las salidas quedan pegadas, y no hay salto de línea. Por lo tanto el ‘prompt’ ‘>>>’ queda unido también.
Una variante del ejemplo anterior es no eliminar el salto del último print( ), de tal modo que el
salto se de, y no afecte el prompt.
print('A',end='');print('B',end='');print('C',end='');print('D')
ABCD
>>>
CONSOLA PYTHON Y LA FUNCIÓN input()
La entrada de datos desde el usuario es solo para parametrizar procesos, o para almacenar nuevos datos en un repositorio de datos.
En esta sección usaremos una forma muy básica de ingreso de datos interactivo; esto es, el sistema para, pide datos, y luego con los datos podrá continuar su trabajo.
input( ).
Si no usas parámetros en la llamada a input( ), el programa interrumpe su ejecución, y pide el ingreso de una cadena. Tan pronto el usuario pulsa la tecla Enter, la función devuelve la cadena que el usuario ingreso.
Si el usuario igualó una variable a la llamada, la variable queda apuntando al valor.
>>> data = input()
dato sin prompt #la ejecución se interrumpe mientras se ingresa el dato
>>>
>>> data #la variable ‘data’ queda cargada con la entrada del usuario
'dato sin propmt'
>>>
input( string ).
Si el usuario usa como parámetro una string, dicho texto aparece en la consola antes de la solicitud del dato.
Eso permite darle contexto al dato que se está pidiendo al usuario. De resto el comportamiento es el mismo anterior.
>>> data = input("ingrese dato: ")
ingrese dato: dato con prompt #ejecución se interrumpe mientras se ingresa el dato
>>> data
'dato con prompt'
>>>
Debido a que la función input captura una cadena, los datos numéricos deben ser convertidos antes de ser usados. También es importante tener en cuenta que, si no ingreso datos y pulso Enter, una conversión sobre un dato vacío puede emitir error.
>>> x = input("número de etapas: ")
número de etapas: 10
>>> type(x)
<class 'str'>
>>> x = int(x)
>>> type(x)
<class 'int'>
LAS FUNCIONES input() Y print() EN NUESTROS PROGRAMAS
Dentro de nuestros programas, el comportamiento de las instrucciones es el mismo presentado dentro de la consola Python.
A continuación se presenta un ejemplo para poder aclarar mejor el uso de instrucciones input( ) y print( ).
Se debe tener muy en cuenta que el tema de ingreso y salida de datos es muy extenso si se considera que los datos pueden ser formaterados en su salida para mayor legibilidad.
Aquí solo estamos presentando una alternativa de interacción que le permita ingresar datos y presentar datos de una forma inmediata para hacer pruebas y resolver algunos problemas básicos.
Ejemplo
Escriba una función python que le permita a un usuario ingresar el volumen de una esfera.
A partir de ese dato, llame una función que determine el desperdicio de guardar la esfera en una caja de lado igual al diámetro de la esfera. Presente al usuario el desperdicio.
R/
def calcularDesperdicio(volEsfera:float)->float:
"""calcular el desperdicio de volumen de una espera en un cubo"""
pi = 3.14159265358
diámetro = ( 3 * volEsfera / ( 2 * pi ) ) ** 0.5
volCubo = diámetro ** 3
desperdicio = volCubo - volEsfera
return desperdicio
def main():
"""programa cálculo de desperdicio"""
vol = input("ingrese el volumen de la esfera: ")
vol = float(vol)
desp = calcularDesperdicio(vol)
print("El desperdicio es: ", desp)
main() #llamada a la función principal
En la función calcularDesperdicio, se recibe como parámetro el volumen de la esfera en la variable volEsfera, y a partir de ese valor se calcula el diámetro de la esfera que se asocia a la variable diámetro.
Ese diámetro deberá corresponder con le lado del cubo.
Se calcula el volumen del cubo, y finalmente se le resta a ese volumen el volumen de la esfera para determinar el volumen de desperdicio.
La función main( ) es un procedimiento. Dado que esta función es por donde comenzará la interacción con el usuario, y en ella misma daremos los resultados, la llamaremos main( ), pero podría haber sido cualquier.
Hacemos la llamada a la función main( ).
La función main pide al usuario, a través e la función input( ), ingresar un valor correspondiente al volumen de la esfera que va a guardar.
El valor lo guarda en la variable vol. Pero debido a que la función devuelve una cadena, hay que convertir esa cadena en valor antes de enviarlo a la función, para lo cual el valor transformado volvemos asociarlo a la variable vol.
Estamos listos. Hacemos la llamada a la función calcularDesperdicio( volEsfera ), y el valor calculado lo guardamos en la variable desp.
Finalmente usamos la función print( ) para presentar al usuario el resultado.
Estas consolas han perdurado en el tiempo, y se mantienen hoy vigentes en sistemas operativos como Windows, macOS, y linux.
En todos los sistemas operativos en los que se trabaje con una interfaz gráfica, siempre habrá una consola del sistema en la cual puedes correr comandos.
Cada que corres un programa en Python, la interacción se hace directamente en una consola. Sin embargo, existen muchas librerías que te permiten capturar y presentar datos en una interfaz gráfica. De hecho, Python trae una librería estándar para hacerlo, que es el defacto para la construcción de interfaz gráfica con python: la librería se llama Tkinter.
En esta sessión conoceremos la forma más básica de interactuar con el usuario a través e la consola.
CONSOLA PYTHON Y LA FUNCIÓN print() SIN FORMATO
La función de ayuda print() de Python permite presentar datos en pantalla.
En esta sección nos apropiaremos de su forma más básica: imprimir datos sin formato en consola, lo que nos permitirá poder interactuar con el usuario de forma inmediata.
print( ).
Nos permite enviar un salto de línea a la pantalla.
El comportamiento de la función print( ) es que, luego que se ejecuta, manda un salto de línea. En este caso y si no hay datos, siempre mandará el salto.
El caracter específico que la función envía es caracter de control de código 10, y que se puede representar como '\n'.
Para imprimir varios saltos de línea, usamos varias llamadas a la función print().
>>> print()
>>>
>>> print();print();print()
>>>
print(dato,… ).
Nos permite enviar datos, incluyendo un salto de línea al final. Debido a que print siempre salta al final, cualquier print( ) subsiguiente comenzará en la línea siguiente.
Python puede imprimir cualquier tipo de dato. La forma en que lo hace cuando no se especifica un formato va a depender del objeto que se imprima.
La coma tiene como función separar cada uno de los datos, para lo cual, siempre adiciona un único espacio, correspondiente al código decimal 32. Al final, siempre va el salto de línea
>>> print(1,2,3, 'A', 'B', 'C', "hello", "hola")
1 2 3 A B C hello hola
>>>
En realidad lo que print imprime es lo que le diga que imprima el objeto llamando el método __str__( ) del objeto concreto, que traen un comportamiento por defecto. Si embargo, se puede modificar este comportamiento.
Si quisiéramos partir las líneas en que se imprimen los datos, podríamos hacer las agrupaciones que gustemos.
>>> print(1,2,3, 'A', 'B', 'C')
1 2 3 A B C
>>> print("hello", "hola")
hello hola
>>>
También podemos usar el character de salto de línea en la posición que se desee.
Esto es, en una sola línea de salida podemos controlar los saltos en las posiciones que deseemos.
>>> print(1,2,3, '\n', 'A', 'B', 'C', '\n', '\n', "hello", "hola")
1 2 3
A B C
hello hola
>>>
Queda a su imaginación entender la teoría dada, y darse cuenta porqué a partir de la segunda línea de salida del ejemplo, se da un espacio antes de comenzar a presenter los datos.
Por ultimo, si desea suprimir el salto, puede reemplazarlo con la sentencia end, que es un parámetro de print, que permite especificar una cadena con la que se quera reemplazazar el salto.
Por ejemplo, para suprimir el salto, puedo especificar una cadena vacía, o un character concreto.
>>> print('A',end='');print('B',end='');print('C',end='');print('D',end='')
ABCD>>>
>>> print('A',end='@');print('B',end='@');print('C',end='@');print('D',end='@')
A@B@C@D@>>>
Al haber suprimido todos los saltos, todas las salidas quedan pegadas, y no hay salto de línea. Por lo tanto el ‘prompt’ ‘>>>’ queda unido también.
Una variante del ejemplo anterior es no eliminar el salto del último print( ), de tal modo que el
salto se de, y no afecte el prompt.
print('A',end='');print('B',end='');print('C',end='');print('D')
ABCD
>>>
CONSOLA PYTHON Y LA FUNCIÓN input()
La entrada de datos desde el usuario es solo para parametrizar procesos, o para almacenar nuevos datos en un repositorio de datos.
En esta sección usaremos una forma muy básica de ingreso de datos interactivo; esto es, el sistema para, pide datos, y luego con los datos podrá continuar su trabajo.
input( ).
Si no usas parámetros en la llamada a input( ), el programa interrumpe su ejecución, y pide el ingreso de una cadena. Tan pronto el usuario pulsa la tecla Enter, la función devuelve la cadena que el usuario ingreso.
Si el usuario igualó una variable a la llamada, la variable queda apuntando al valor.
>>> data = input()
dato sin prompt #la ejecución se interrumpe mientras se ingresa el dato
>>>
>>> data #la variable ‘data’ queda cargada con la entrada del usuario
'dato sin propmt'
>>>
input( string ).
Si el usuario usa como parámetro una string, dicho texto aparece en la consola antes de la solicitud del dato.
Eso permite darle contexto al dato que se está pidiendo al usuario. De resto el comportamiento es el mismo anterior.
>>> data = input("ingrese dato: ")
ingrese dato: dato con prompt #ejecución se interrumpe mientras se ingresa el dato
>>> data
'dato con prompt'
>>>
Debido a que la función input captura una cadena, los datos numéricos deben ser convertidos antes de ser usados. También es importante tener en cuenta que, si no ingreso datos y pulso Enter, una conversión sobre un dato vacío puede emitir error.
>>> x = input("número de etapas: ")
número de etapas: 10
>>> type(x)
<class 'str'>
>>> x = int(x)
>>> type(x)
<class 'int'>
LAS FUNCIONES input() Y print() EN NUESTROS PROGRAMAS
Dentro de nuestros programas, el comportamiento de las instrucciones es el mismo presentado dentro de la consola Python.
A continuación se presenta un ejemplo para poder aclarar mejor el uso de instrucciones input( ) y print( ).
Se debe tener muy en cuenta que el tema de ingreso y salida de datos es muy extenso si se considera que los datos pueden ser formaterados en su salida para mayor legibilidad.
Aquí solo estamos presentando una alternativa de interacción que le permita ingresar datos y presentar datos de una forma inmediata para hacer pruebas y resolver algunos problemas básicos.
Ejemplo
Escriba una función python que le permita a un usuario ingresar el volumen de una esfera.
A partir de ese dato, llame una función que determine el desperdicio de guardar la esfera en una caja de lado igual al diámetro de la esfera. Presente al usuario el desperdicio.
R/
def calcularDesperdicio(volEsfera:float)->float:
"""calcular el desperdicio de volumen de una espera en un cubo"""
pi = 3.14159265358
diámetro = ( 3 * volEsfera / ( 2 * pi ) ) ** 0.5
volCubo = diámetro ** 3
desperdicio = volCubo - volEsfera
return desperdicio
def main():
"""programa cálculo de desperdicio"""
vol = input("ingrese el volumen de la esfera: ")
vol = float(vol)
desp = calcularDesperdicio(vol)
print("El desperdicio es: ", desp)
main() #llamada a la función principal
En la función calcularDesperdicio, se recibe como parámetro el volumen de la esfera en la variable volEsfera, y a partir de ese valor se calcula el diámetro de la esfera que se asocia a la variable diámetro.
Ese diámetro deberá corresponder con le lado del cubo.
Se calcula el volumen del cubo, y finalmente se le resta a ese volumen el volumen de la esfera para determinar el volumen de desperdicio.
La función main( ) es un procedimiento. Dado que esta función es por donde comenzará la interacción con el usuario, y en ella misma daremos los resultados, la llamaremos main( ), pero podría haber sido cualquier.
Hacemos la llamada a la función main( ).
La función main pide al usuario, a través e la función input( ), ingresar un valor correspondiente al volumen de la esfera que va a guardar.
El valor lo guarda en la variable vol. Pero debido a que la función devuelve una cadena, hay que convertir esa cadena en valor antes de enviarlo a la función, para lo cual el valor transformado volvemos asociarlo a la variable vol.
Estamos listos. Hacemos la llamada a la función calcularDesperdicio( volEsfera ), y el valor calculado lo guardamos en la variable desp.
Finalmente usamos la función print( ) para presentar al usuario el resultado.
SESIÓN #6 DE EJERCITACIÓN:
ENTRADA Y SALIDA BÁSICA DE USUARIO
Use el editor de texto con el que más cómodo se sienta, y construya programas para resolver los siguientes problemas. Para cada uno de los problemas enumerados, escriba una función main() que se encargue de la captura de datos de entrada y salida, y de la llamada de una función o funciones centrales que resuelven el problema.
Tenga en cuenta que los valores que captura con input() son string, por lo que deberá convertirlos a enteros o flotantes para poder luego llamar la función.
Para la conversión de string a flotante use la función float().
Para la conversión de string a entero use la función int().
Tenga en cuenta que los valores que captura con input() son string, por lo que deberá convertirlos a enteros o flotantes para poder luego llamar la función.
Para la conversión de string a flotante use la función float().
Para la conversión de string a entero use la función int().
- Nombre y Apellidos.
Escriba un procedimiento en Python que le pida al usuario nombres y apellidos. Y se lo presente apellidos, nombre. - Media aritmética.
Escriba una función en Python llamada media_aritmética_dos_num(). Para la media aritmética de dos números, halle la suma de los números dividida entre 2. Luego escriba un procedimiento que capture dos valores por medio de la función input(). A continuación, con los dos valores, llame la función media_aritmética(). Presente el resultado de la llamada al usuario, usando la función print(). - Media geométrica.
Siga la misma línea del problema anterior para desarrollar una función en Python llamada media_geométrica(). La media geométrica de dos números se define como la raíz cuadrada del producto de los números. Para sacar la raíz cuadrada, use exponente 0.5. - Media armónica.
Siga la misma línea de los dos problemas anteriores, y escriba una función en Python llamada media_armónica(), para la media armónica de dos números, que se define como el doble del producto de los números dividida la suma de los números. - Medias.
Escriba un procedimiento en Python que permita que un usuario ingrese dos números. El procedimiento invocará las funciones construidas en los 3 literales anteriores, para presentarle al usuario la media aritmética, la media geométrica, y la media armónica de los dos números que el usuario ingrese. - Volúmenes cubo y esfera.
Escriba un procedimiento en Python que permita que un usuario ingrese dos números que representan el radio y el lado de un cubo, y determine si el volumen del cubo cabe en el radio. Para los cálculos de volumen, use funciones adicionales que son invocadas. Presente títulos al usuario al momento de la entrada y al momento de la salida. - Suma de números sin usar ciclos.
Para hallar la suma de los primeros n números sin usar ciclos, se puede multiplicar n por n+1, y a ese resultado se le divide por 2, y de esa forma no hay que construir un ciclo paso a paso.(Zwillinger, 2018, p.19).
Construya una función Python que determine la suma de los n primeros número naturales.
Luego use interacción con el usuario para pedirle n y presentarle la suma de los primeros n números.
BIFURCACIONES NO CÍCLICAS
CONDICIONAL if, una bifurcación
Python tiene forma de hacer bifurcaciones condicionales en el código, tal y cual se hizo en pseudocódigo. La única diferencia es, como es de esperarse en muchos lenguajes, su estricta sintaxis.
La sintaxis Python se define como:
if condición :
bloque de código
Python tiene una sintaxis simple para un condicional de una sola bifurcación, que se ve reflejada con los ejemplos de consola que se presentan.
Tenga en cuenta que, en la consola, toda instrucción del lenguaje que sea construida es evaluada tan pronto sea posible.
>>> if True: #la condición siempre es verdadera
... print("ok")
...
ok
>>>
En el ejemplo presentado, True es la condición, y por lo tanto, la instrucción print( ) se tiene que ejecutar, y es por eso que el mensaje 'la condición es verdadera' se despliega en pantalla.
En cambio
>>> if False: #la condición nunca es verdadera
... print("no ok")
...
no ok
>>>
En este caso, la condición es el valor False, y, por lo tanto, al no ser cierta la condición, no se ejecuta la instrucción print( ) como puede verse.
Los dos puntos ( : ), luego de la condición son obligatorios en Python, e indican la apertura de un bloque, que será la bifurcación hasta que termine el if.
La instrucción if le avisa a Python, por medio del caracter dos puntos ( : ), que abrirá un nuevo bloque.
Por lo tanto, deberemos usar una nueva indentación. El bloque if termina cuando una instrucción no conserve la columna de tabulado, o no hayan más instrucciones.
Python tiene forma de hacer bifurcaciones condicionales en el código, tal y cual se hizo en pseudocódigo. La única diferencia es, como es de esperarse en muchos lenguajes, su estricta sintaxis.
La sintaxis Python se define como:
if condición :
bloque de código
Python tiene una sintaxis simple para un condicional de una sola bifurcación, que se ve reflejada con los ejemplos de consola que se presentan.
Tenga en cuenta que, en la consola, toda instrucción del lenguaje que sea construida es evaluada tan pronto sea posible.
>>> if True: #la condición siempre es verdadera
... print("ok")
...
ok
>>>
En el ejemplo presentado, True es la condición, y por lo tanto, la instrucción print( ) se tiene que ejecutar, y es por eso que el mensaje 'la condición es verdadera' se despliega en pantalla.
En cambio
>>> if False: #la condición nunca es verdadera
... print("no ok")
...
no ok
>>>
En este caso, la condición es el valor False, y, por lo tanto, al no ser cierta la condición, no se ejecuta la instrucción print( ) como puede verse.
Los dos puntos ( : ), luego de la condición son obligatorios en Python, e indican la apertura de un bloque, que será la bifurcación hasta que termine el if.
La instrucción if le avisa a Python, por medio del caracter dos puntos ( : ), que abrirá un nuevo bloque.
Por lo tanto, deberemos usar una nueva indentación. El bloque if termina cuando una instrucción no conserve la columna de tabulado, o no hayan más instrucciones.
EJEMPLO: LANZAMIENTO DE MONEDA
Defina en Python una función que lance una moneda, e indique qué lado cae. Use las palabras ‘Cara’ o ‘Sello’. Use la librería random de Python para generar un número pseudoaleatorio usando la función random( ). Para el efecto, genere un número entre 0 y 1. Si el número es mayor a 0.5, es cara, y en ese caso la función devuelve la cadena‘Cara’. En caso contrario, la función devuelve‘Sello’. Construya, además, una función que haga tres lanzamientos de prueba, y finalmente llame la función que haga los lanzamientos. def lanzarmoneda() -> str: #definición from random import random moneda = random() lado = 'Sello' if moneda > 0.5: lado = 'Cara' return lado def hacertreslanzamientos(): #definición print(lanzarMoneda()) print(lanzarMoneda()) print(lanzarMoneda()) return hacertreslanzamientos () #llamada a la función EXPLICACIÓN. En el ejemplo, la función que lanza monedas, lanzarmoneda( ), se encarga de un lanzamiento y devuelve el resultado de 'Cara' o 'Sello'. Esta función contiene un if, que tiene la opción de hacer una bifurcación, antes de integrarse de nuevo al bloque de código principal. La función hacertreslanzamientos( ) es una función que interactúa con el usuario e consola debido al print, y que hace tres lanzamientos que presenta en consola. Finalmente, se hace en la última línea que se muestra de código, una llamada a la función hacertreslanzamientos(). Un ejemplo de ejecución de ese código fuente, dará como resultado la llamada de la última línea, que a su vez hará tres lanzamientos de moneda aleatorios, por ejemplo, Cara Cara Sello |
BLOQUES INDENTADOS EN PYTHON
Cuando en Python una instrucción está exactamente debajo de otra, se consideran dentro del mismo bloque.
Por ejemplo, la primera instrucción en un script Python define un bloque; por lo tanto, si la instrucción que sigue a la primera no se encuentra en la misma posición, se genera un error de indentación.
Un nuevo bloque de indentación se abre cuando aparecen dos puntos ( : ).
Las instrucciones def para definir funciones, if, elif, else para bifurcar código, while para ciclos y for para iteraciones sobre colecciones, requieren para abrir su propio bloque el caracter dos puntos ( : ).
Luego del caracter dos puntos, siguen las instrucciones del nuevo bloque, que deberá comenzar en cualquier columna más a la derecha. Por lo tanto, la posición de la primera línea del bloque define la posición de todas las líneas del mismo bloque.
Tan pronto una instrucción aparece más a la izquierda, pero debajo de una previa, indica que se cerró el bloque anterior.
Cuando en Python una instrucción está exactamente debajo de otra, se consideran dentro del mismo bloque.
Por ejemplo, la primera instrucción en un script Python define un bloque; por lo tanto, si la instrucción que sigue a la primera no se encuentra en la misma posición, se genera un error de indentación.
Un nuevo bloque de indentación se abre cuando aparecen dos puntos ( : ).
Las instrucciones def para definir funciones, if, elif, else para bifurcar código, while para ciclos y for para iteraciones sobre colecciones, requieren para abrir su propio bloque el caracter dos puntos ( : ).
Luego del caracter dos puntos, siguen las instrucciones del nuevo bloque, que deberá comenzar en cualquier columna más a la derecha. Por lo tanto, la posición de la primera línea del bloque define la posición de todas las líneas del mismo bloque.
Tan pronto una instrucción aparece más a la izquierda, pero debajo de una previa, indica que se cerró el bloque anterior.
def espar(x): #bloque 1 y apertura de bloque #2
|
En el ejemplo, la cabecera de la función corresponde al bloque más externo, que denominaremos bloque 1. Dentro de la función, varias instrucciones son de un bloque más interno, que denominaremos bloque 2. Solo una instrucción corresponde al bloque 3, y es la instrucción es = True.
CONDICIONAL if-else, dos bifurcaciones
En Python, la condición de un if define si se ejecuta una bifurcación adicional que denominaremos bifurcación then.
Y si la condición es falsa, la bifurcación no se da, y continuamos con el flujo normal. Es posible asociar al if un bloque adicional antes de continuar con el flujo central.
Esto se logra con la adición de una sentencia else, que define una nueva bifurcación, que solo se ejecuta cuando la condición es falsa.
No sobra aclarar que, una instrucción if, solo puede contener una sentencia else. Esto se debe a la característica binaria del tipo booleano.
La sintaxis Python se define como:
if condición:
bloque de código cuando la condición es verdadera
else :
bloque de código cuando la condición es falsa
La bifurcación else permite abrir cualquier tipo de bloque, de modo que podremos incluir nuevos if y anidarlos para resolver lógicas más complejas.
En Python, la condición de un if define si se ejecuta una bifurcación adicional que denominaremos bifurcación then.
Y si la condición es falsa, la bifurcación no se da, y continuamos con el flujo normal. Es posible asociar al if un bloque adicional antes de continuar con el flujo central.
Esto se logra con la adición de una sentencia else, que define una nueva bifurcación, que solo se ejecuta cuando la condición es falsa.
No sobra aclarar que, una instrucción if, solo puede contener una sentencia else. Esto se debe a la característica binaria del tipo booleano.
La sintaxis Python se define como:
if condición:
bloque de código cuando la condición es verdadera
else :
bloque de código cuando la condición es falsa
La bifurcación else permite abrir cualquier tipo de bloque, de modo que podremos incluir nuevos if y anidarlos para resolver lógicas más complejas.
EJEMPLO: FUNCIÓN PISO
La función techo de un número real, es un concepto matemático que calcula el número entero menor o igual a un número real dado. Escriba una función piso en Python. R/ def piso(x:float) -> tuple: if x < 0: x = int(x+1) else: x = int(x) return x Nota: aunque hay otra forma de hacer este algoritmo con una sola bifurcación, se hace con dos bifurcaciones para efectos didácticos. De hecho, la solución con dos bifurcaciones es más limpia. EJEMPLO: TUPLA ORDENADA
Elabore una función Python que, dados dos números reales cualquiera los entregue siempre ordenados, primero el menor, y luego el mayor. R/ def ordenadosascendente(x:float , y:float) -> tuple : if x > y: #abre bloque para verdad orden = (y,x) else: #abre bloque para falsedad orden = (x,y) return orden Notas. En este caso se van a devolver dos valores, por lo que debemos usar un tipo de dato compuesto, ya sea tupla, estructura o arreglo. La tupla es la forma más simple para estos casos. EJEMPLO: AÑO BISIESTO
Un año bisiesto se define como aquel que es divisible por 4, pero no lo es por 100, excepto si es divisible por 400. Los años 1900, 1400, 1500, 1700 no son bisiestos. Los años 1200, 1600, 2000 son bisiestos. Construya una función Python para determinar si un año, dado como parámetro, es bisiesto. R/ def esbisiesto(año:int) -> bool : bis = False if año % 400 == 0: #año es divisible por 400 bis = True else: if año % 4 == 0 and año % 100 != 0: #divisible por 4 pero no por 100 bis = True return bis RETO. Para efectos prácticos, esta función pudo haber sido escrita mucho más simple. Se deja al lector la inquietud de cómo hacer lo mismo usando sólo instrucciones relacionales y lógicas sin necesidad de el uso de la sentencia de control de flujo if. |
CONDICIONAL if-elif-else, múltiples bifurcaciones
La cláusula elif de Python adiciona una nueva condición al if actual. Se pueden adicionar tantos elif como se desee a un if, lo que permite establecer estructuras de if anidados simplificadas que no demanden nuevas indentaciones.
El elif es otro tipo de forma de abrir nuevas bifurcaciones a un if, tantas como se requiera.
Sin embargo, tiene la desventaja frente a los if anidados, que un elif no tiene else.
Un if, junto con sus estructuras elif pueden ir acompañados de una única estructura else.
Esto se debe a la filosofía de la sentencia elif. Si se desea que un nuevo ifcontenga un else adicional, deberá anidarlo.
La sintaxis Python se define como:
if condición :
bloque de código
elif condición :
bloque de código
...
else :
bloque de código si ninguna condición es cierta
Note que sola condición es posible, y, que tan pronto se cumple alguna y se ejecuta el bloque asociado, termina el if.
La cláusula elif de Python adiciona una nueva condición al if actual. Se pueden adicionar tantos elif como se desee a un if, lo que permite establecer estructuras de if anidados simplificadas que no demanden nuevas indentaciones.
El elif es otro tipo de forma de abrir nuevas bifurcaciones a un if, tantas como se requiera.
Sin embargo, tiene la desventaja frente a los if anidados, que un elif no tiene else.
Un if, junto con sus estructuras elif pueden ir acompañados de una única estructura else.
Esto se debe a la filosofía de la sentencia elif. Si se desea que un nuevo ifcontenga un else adicional, deberá anidarlo.
La sintaxis Python se define como:
if condición :
bloque de código
elif condición :
bloque de código
...
else :
bloque de código si ninguna condición es cierta
Note que sola condición es posible, y, que tan pronto se cumple alguna y se ejecuta el bloque asociado, termina el if.
EJEMPLO: TIPO ESPECTRAL ESTELAR
La temperatura superficial en grados kelvin de una estrella difiere dependiendo de la masa y la edad. Existe una clasificación básica que se conoce como tipo espectral de la estrella. Según dicha clasificación,las estrellas pueden ser clasificadas en alguna de las categorías O, B, A, F, G, K, M[1], de acuerdo a la siguiente distribución de temperaturas: tipo espectral O: temperaturas atmosféricas mayores a 33.000 K tipo espectral B: temperaturas atmosféricas entre 10.000 K y 33.000 K tipo espectral A: temperaturas atmosféricas entre 7.000 K y 10.000 K tipo espectral F: temperaturas atmosféricas entre 6.000 K y 7.500 K tipo espectral G: temperaturas atmosféricas entre 5.200 K y 6.000 K tipo espectral K: temperaturas atmosféricas entre 3.700 K y 5.200 K tipo espectral M: temperaturas atmosféricas menores a 3.700 K Construya una función Python que, dada la temperatura espectral en grados kelvin, determine el tipo espectral. R/ def startype(t:float)->str: if t <= 3700 : return 'M' elif t <= 5200 : return 'K' elif t <= 6000 : return 'G' elif t <= 7000 : return 'F' elif t <= 10000 : return 'A' elif t <= 33000 : return 'B' else : return 'O' [1] En la literatura astronómica, los astrónomos recuerdan las letras del tipo espectral y su orden por medio de la nemotecnia Oh, Be A Fine Girl(Guy), ¡Kiss Me!, que en español se lee (Oh, se una buena chica ( o buen chico) y bésame) |
CONDICIONAL terciario
En Python, como en muchos otros lenguajes, existe una sentencia if alternativa, que actúa como expresión. Este if es una expresión que, a cambio de controlar bloques de código, devuelve dos posibles valores, según sea la condición falsa o verdadera.
Conocido en otros lenguajes como operador terciario, toma tres valores:
La sintaxis Python es:
expresión-verdadero if condición else expresión-falso
Tan pronto se evalúa la condición, si es verdadera, se devuelve como valor la evaluación de expresión-verdadero. Pero si la condición es falsa, se devuelve como valor la evaluación de expresión-falso.
Ambas expresiones deberán estar disponibles para que la sintaxis sea válida.
El resultado de la expresión puede ser usado en cualquier contexto y muchos problemas muy simples pueden ser resueltos con esta expresión.
Conocido en otros lenguajes como operador terciario, toma tres valores:
- una condición.
- una expresión para cuando la condición es verdadera.
- una expresión para cuando la condición es falsa.
La sintaxis Python es:
expresión-verdadero if condición else expresión-falso
Tan pronto se evalúa la condición, si es verdadera, se devuelve como valor la evaluación de expresión-verdadero. Pero si la condición es falsa, se devuelve como valor la evaluación de expresión-falso.
Ambas expresiones deberán estar disponibles para que la sintaxis sea válida.
El resultado de la expresión puede ser usado en cualquier contexto y muchos problemas muy simples pueden ser resueltos con esta expresión.
EJEMPLO: VALOR ABSOLUTO
Escriba en Python una función que devuelva el valor absoluto de un número. Use un condicional ternario Python. R/ def abs(x:float) -> float: return x if x > 0 else -x Debido a que la función es simple, podemos dejar todo el código en la misma línea: def abs(x:float) -> float: return x if x > 0 else -x |
Por supuesto, un condicional terciario, puede llevar dentro de sus expresiones otros operadores terciarios, lo que puede llevar a expresiones un poco crípticas. Sin embargo, es un condicional bastante poderoso en ciertas situaciones done se requiere generar un valor de forma condicionada.
SESIÓN #7 DE EJERCITACIÓN:
BIFURCACIÓN NO CÍCLICA:
if, if-else, if-elif-else
Use la plataforma online repl.it, o use la plataforma google Google Colab, o cualquier otra plataforma online de su preferencia, o trabaje directamente local en un ambiente como Visual Studio Code, o el editor estándar de Python, o el IDE Spyder, o use directamente un editor de textos, para construir funciones a partir de los problemas que se plantean.
A las funciones de cada problema, constrúyale varias invocaciones de prueba para verificar su integridad. Si lo desea, construya adicionalmente una función main() que le permita interactuar con el usuario para pedirle datos, enviarlos a sus funciones, y obtener resultados presentables al usuario.
A las funciones de cada problema, constrúyale varias invocaciones de prueba para verificar su integridad. Si lo desea, construya adicionalmente una función main() que le permita interactuar con el usuario para pedirle datos, enviarlos a sus funciones, y obtener resultados presentables al usuario.
- Sleep_in.
Construya una función Python llamada sleep_in(), que reciba dos parámetros, y determine si dormimos o no dormimos. El primero es True si es un día de semana, y el segundo es True si son vacaciones. La función devuelve si estamos durmiendo. Solo dormimos si no es un día de semana y estamos en vacaciones.("CodingBat Python", 2020)
Ejemplo:
sleep_in(False, False) → True
sleep_in(True, False) → False
sleep_in(False, True) → True - Monkie trouble.
Construya una función Python que reciba dos parámetros a_smile y b_smile que indican cada una si un mono a está sonriendo, y si un mono b está sonriendo. Estamos en problemas si ambos monos están sonriendo, o si ambos monos no están sonriendo. La función devuelve True, si estamos en problemas. ("CodingBat Python", 2020)
Ejemplos:
monkey_trouble(True, True) → True
monkey_trouble(False, False) → True
monkey_trouble(True, False) → False - Diff21.
Construya una función Python que, dado un número entero n, devuelva la diferencia absoluta entre n y 21. Si n es mayor a 21, devuelve el doble de la diferencia. ("CodingBat Python", 2020)
Ejemplos:
diff21(19) → 2
diff21(10) → 11
diff21(21) → 0 - Parrot troube.
Tenemos una lora que habla duro cuando se alborota. Construya una función Python llamada parrot_trouble() que recibe un parámetro que indica si el loro está hablando o no duro, y la hora en que se hizo el monitoreo, en el rango 0..23. La función indica si estamos en problemas, algo que sucede si la lora habla duro antes de las 7, o después de las 10 de la noche. ("CodingBat Python", 2020)
Ejemplos:
parrot_trouble(True, 6) → True
parrot_trouble(True, 7) → False
parrot_trouble(False, 6) → False - Positivo negativo.
Construya una función Python llamada posneg(), que reciba dos números enteros y un valor de signo que indica negatividad. La función devuelve True si uno de los números es negativo y otro positivo, excepto si el valor de negatividad es True, pues en ese caso devuelve True solo si ambos son negativos. ("CodingBat Python", 2020)
Ejemplos:
pos_neg(1, -1, False) → True
pos_neg(-1, 1, False) → True
pos_neg(-4, -5, True) → True - Función Heaviside.
Construya una función Python llamada heaviside(), la cual, dado un valor numérico, devuelve 1 si el valor dado es mayor o igual a cero, y devuelve cero si x es menor que cero. - Numeración de pisos en edificios.
Muchos edificios enumeran los pisos de forma diferente: el primer piso es el 1 y no el 0, y algunas veces no hay piso 13 por superstición. Los pisos por debajo de cero (los pisos negativos), siempre son negativos sin modificaciones en todos los edificios. Escriba una función en Python que para un edificio donde el primer piso es el 1 y no hay piso 13, determine la respectiva numeración para un edificio cuyo piso base será 0, y sí tiene piso 13.
Por ejemplo:
para 1, la función devuelve 0
para 0, la función devuelve 0
para 5, la función devuelve 4
para 15, la función devuelve 13
para -3, la función devuelve -3
(Codewars - https://www.codewars.com/kata/574b3b1599d8f897470018f6) - Función signum.
- Construya una función Python llamada signum(), la cual, dado un valor numérico, devuelva 1 si el valor es positivo, -1 si el valor es negativo, o 0 (cero) si el valor es cero.}
- Par o impar.
Construya una función Python parity(),que determine si un número n dado es par o impar. Si es un número par, la función devuelve 2; pero si es impar, la función devuelve 1. En caso que el número sea cero(0), la función devuelve 0. Construya otra función tupleparity(), que reciba una tupla con tres números, y que devuelva la paridad de la tupla.
Por ejemplo,
para la tupla (71,82,13), tupleparity() devuelve la tupla (1,2,1).
para la tupla (249,45226,0), tupleparity() devuelve (1,2,0). - Siglo del año.
Construya una función Python que, dado un entero positivo cualquiera que representa un año, determine el siglo al que corresponde el año.
Por ejemplo,
para los años 1 a 100, el siglo es 1.
Para los años 101 a 200, el siglo es 2.
Para los años 1801 a 1900, el siglo es 190.
Para los años 1901 a 2000, el siglo es 20.
Tip: revise el operador módulo.
Otro tip: revide la función ceil() y floor() de los números enteros. - Nombre de dígito.
Escriba una función Python que reciba un dígito entero en el rango 0 al 9, y devuelva su nombre. - Test de divisibilidad empírico.
Construya una función Python que no use el operador %, para determinar divisibilidad, sino que usa reglas empíricas para determinar por cuáles números entre el 2 y el 10 dividen a número n dado como parámetro de la función. Se pueden usar divisiones enteras si se desea.
La función devuelve una lista Python con los números divisores.
La siguiente prueba de divisibilidad se basa en un conjunto de reglas que se expresan en el libro CRC Standard Mathematical Tables and Fórmulas (Zwillinger, 2018, p.5) y dice:
Divisible por 2: el último dígito es divisible por 2
Divisible por 3: la suma de los dígitos es divisible por 3
Divisible por 4: el número formado por los dos últimos dígitos es divisible por 4
Divisible por 5: el último dígito es divisible por 0 o por 5
Divisible por 6: el número es divisible por 2 y por 3
Divisible por 9: la suma de los dígitos es divisible por 9
Divisible por 10: el último dígito es 0 - Duo ordenado.
Construya una función Python que, dada una tupla de dos valores, devuelva una tupla donde los valores están ordenados de menor a mayor. Por ejemplo, si entra la tupla (9,7), sale la tupla (7,9). - Tripleta ordenada.
Construya una función Python que, dada una tupla de tres valores, devuelva una tupla donde los valores están ordenados de menor a mayor. Por ejemplo, si a la función entra la tupla (9,8,1), de la función sale la tupla (1,8,9). - Volumen total distintos objetos.
Construya una función Python llamada volumeAccumulator(), que reciba una lista Python que contiene siempre 3 elementos que representan información de figuras 3D. La función devuelve el volumen total. Cada elemento contiene una tupla y cada tupla contiene información requerida para calcular volúmenes. Si en alguna tupla viene un solo dato, se trata del radio de una esfera. Si en alguna tupa vienen 2 datos, se trata, en su orden, de la altura y del radio de un cilindro. Si en alguna tupla vienen 3 elementos, se trata, en su orden, de dos radios y la altura de un tronco regular. Las funciones para volúmenes son:
volesfera = 4/3.π.r^3
volcilindro = h.π.r^2
voltronco = 1/3.h.π( R^2 + R.r + r^2) - Lista de tripletas ordenadas.
Construya una función Python tripletsort_in_quartetlist(), que reciba una lista Python que contiene 4 elementos. Cada elemento de la lista contiene una tupla que puede ser de 2 o de 3 elementos. La función devuelve la lista con las tuplas ordenadas dentro de la lista. Por ejemplo, si la lista es [(63,77,1),(9,2)], la función devuelve la lista [(1,63,77),(2,9)]. - Conversor hora 24 a 12.
Construya una función Python convert_to_twelve(), que recibe como parámetro una string que representa una hora en formato de 24 horas "hh:mm", y lo convierta a una string en formato 12 horas. Por ejemplo:
la hora "15:39" se convierte a "3:39 pm"
la hora "7:00", se convierte a "7:00 am"
la hora "18:40" se convierte a "6:40 pm" - Orgánica.
Construya una función Python llamada alcano() que, dado el número de carbonos de un alcano entre 1 y 10, determine el nombre de la molecula entre “met”, “et”, “prop”, “but”, “pent”, “hex”, “hept”, “oct. Adicione al final el sufijo “ano” y devuelva el nombre. Por ejemplo, si la función recibe el número 7, devuelve "heptano".
Luego haga una función llamada compuesto-orgánico(), que reciba una tupla de hasta 3 números entre 1 y 8 (podría ser de uno o dos números solamente también), y devuelva una lista con los nombres obtenidos. Por ejemplo, si el dato de entrada es la tupla (7,8,3), devuelve la lista ["heptano","octano","propano"]. - Validar fecha.
Dado un año, mes y día, determine si se trata de una fecha válida:
año positivo
mes entre 1 y 12
día compatible con el mes.
En el caso que el año sea bisiesto, tenga en cuenta que febrero es de 29 días.
Un año es bisiesto si es divisible por 4 o por 400, pero no por 100. Por ejemplo, los años 1700, 1800 y 1900 no son bisiestos. Pero los años 1600, 2000 y 2400 sí lo son. - Formatear hora.
Construya una función Python hour_formater(), que reciba como parámetro un valor flotante (número real) que representa un número de minutos y fracción, y lo convierta a una string que representa la hora en el formato de 12 o 24 horas. Los minutos contienen una parte fraccionaria que identifica los segundos. El número de minutos es inferior a 1440, de tal modo que el valor dado no exceda un día. A la función también ingresa un parámetro booleano que, cuando es True, indica hora en formato 24 horas, y cuando es False, indica hora en formato 12 horas. Si el formato es de 12 horas, la string de salida deberá contener "a.m." o "p.m." según sea el caso.
Por ejemplo, suponga que la función recibe dos valores 780.3 y False.
780 minutos corresponden a 13 horas, y 0.3 minutos a 18 segundos.
Como el otro parámetro es False, la hora deberá salir en formato 12 horas.
Por lo tanto, la respuesta de la función es "1:00:18 p.m."
Otro ejemplo: suponga que ingresan los valores 1374.4 y True.
1374 equivale a 22 horas y 54 minutos. Los 0.4 minutos corresponden a 24 segundos.
El segundo parámetro es True, de modo que el formato es de 24 horas.
La salida, por tanto, es "22:54:24" - El ciego y las peras.
Un agricultor ciego que siembra pera ha desarrollado un gran sentido del tacto, e identifica el tipo de pera por su peso.
Si una pera pesa entre 50 y 70 gramos, es glabra.
Si la pera pesa entre 71 y 90 gramos, es oxyprion.
Si la pera pesa entre 80 y 100 gramos es comunnis.
Identificar las glabra es directo, pero tiene problemas identificando las oxyprion y las comunnis, porque si una pera pesa entre 80 y 90 gramos, existe la posibilidad que sea oxyprion o comunnis según se ve de las características de Peso. Para finalmente identificarlas, el agricultor ciego revisa el mes de recolección. Si es diciembre, es oxyprion, y si es enero es comunnis.
Construya una función Python que reciba el peso y el número del mes de recolección, e identifique el tipo de pera. - Tipo espectral de una estrella.
Construya una función Python llamada spectrattype(), que recibe como parámetro la temperatura superficial de una estrella en grados Kelvin, y determine el tipo espectral, con base en la siguiente distribución:
tipo O: > 33.000
tipo B: 10.000 - 33.000
tipo A: 7.000 - 10.000
tipo F: 6.000 - 7.500
tipo G: 5.200 - 6.000
tipo K: 3.700 – 5.200
tipo M: < 3.700 - Mini Calculadora Aritmética.
Construya una función Python llamada calculate_aritmetic() que, dados dos operandos numéricos, y dado un único caracter entre mas ( + ), menos ( - ), multiplicación ( * ) , y división ( / ), devuelva el cálculo. - Mini Calculadora Trigonométrica.
Construya una función Python llamada calculate_trigonometric() que, dado un operando numérico y una string con alguno de los nombres de funciones trigonométricas entre seno ("sin"), coseno ("cos"), y tangente ("tan"), devuelva el cálculo. - Granos de Cosecha.
Los granos de distintas cosechas muy especiales se recogen en contenedores. Los contenedores están codificados con números enteros de 5 dígitos, de tal modo que:
-Los granos que pesan en promedio 15 gramos se almacenan en contenedores cuyo código comienza en 10, 30 Y 87.
-Los granos que pesan en promedio 18 gramos se almacenan en contenedores cuyo código comienza con 35, 95, y 45.
-Los granos que pesan en promedio 20 gramos se almacenan en contenedores cuyo código comienza con 12, 31, y 71.
-Todos los demás códigos corresponden a contenedores destinados a almacenar tierra abonada.
El código del contenedor también especifica la especie del grano, de tal modo que:
-Los códigos terminados en 18,28 y 38 corresponden a la especie Alphus.
-Los códigos terminados en 32,56 y 78 corresponden a la especie Betus.
El tercer dígito de los códigos corresponde al semestre de recolección 1 o 2.
Se desea que el algoritmo ayude a la valoración del grano en contenedores que pasan por una banda que lee una string que representa el tipo de grano, y el peso del contenedor en kilogramos. Con esta información, se procede a calcular el valor de los contenedores, así:
-granos en promedio 15 gramos tienen un valor base de 10 centavos.
-granos en promedio 18 gramos tienen un valor base de 20 centavos.
-granos en promedio 20 gramos tienen un valor base de 30 centavos.
-granos del primer semestre tienen un recargo del 20% del valor base.
-granos del segundo semestre tienen un recargo del 23% del valor base.
-granos de la especie Alphus tienen un recargo del 3% del valor base.
-granos de la especie Betus tienen un recargo del 7%. - Elabore una función Python llamada container_valoration(), que reciba una cadena que representa el código de contenedor, y un valor numérico que representa el peso de contenedor en kilogramos, y calcule el valor total del contenedor.
- Día sin iva.
Un grupo terrorista desea aprovechar los días sin iva para comprar armamento durante los días de cuarentena por ataques del virus SARS-Cov-2. Construya una función que reciba una tupla f, con el mes inicial y el mes final de cuarentena, un dato d que es el día sin iva dentro de cualquier mes de promociones, y otra tupla m con el mes y el día en el que el campamento terrorista estará cerca a la ciudad. El grupo terrorista solo puede hacer compras si se encuentra cerca a la ciudad 3 días antes del día sin iva. Construya una función Python que determine si el grupo terrorista podrá hacer compras sin iva. - Prefijo adecuado.
Construya una función Python que reciba como parámetro una tupla con dos de alguna de las palabras "agua","tierra", "aire", "vida", y devuelve otra tupla con las mismas palabras precedida por el pronombre adecuado "le" o "la" según sea el caso. Entre el prefijo y la palabra se debe dejar un espacio. Por ejemplo, si la tupla es ("agua","aire"), la salida de la función es ("el agua","el tierra"). - Distribución de asientos.
Se tiene la información de distribución de un Avión Air Bus A380. El Airbus A380 tiene dos áreas con asientos. El área superior es para pasajeros con clase premium y business. La clase premium tiene dos filas de asientos y cada asiento está identificado de la letra A a la letra D con pasillos entre el primer y el segundo asiento, y entre el tercero y cuarto asiento de ambas filas. Las filas 3 a 20 son para pasajeros de clase business. En la clase business hay seis asientos en cada fila y cada asiento está identificado de la letra A a la F. Los pasillos de la clase business están entre el segundo y tercer asiento, y entre el cuarto y el quinto asiento de todas las filas. El área inferior es para pasajeros de clase económica, y sus filas están enumeradas de la 21 a la 65, y cada asiento está identificado con letras de la A a la K (the letter I is no se usa y se omite). En esta área para clase económica, los corredores están entre las sillas tercera y cuarta, y entre las sillas séptima y octava de cada fila.
Elabore una función Python que determine si un asiento está en la "ventana","pasillo", "otro". La función Python recibe como parámetro el número de la fila y la letra del asiento.
Ejemplo.
Si se pasa 3 y C, el algoritmo deberá decir "pasillo".
Si se pasa 64 y A, el algoritmo deberá informar "ventana".
Si se pasa 21 y F, el algoritmo deberá decir "otro".
BIFURCACIONES CÍCLICAS
En Python solo hay dos estructuras de bucle. Pero, estrictamente hablando, solo una es un bucle condicionado, y es la instrucción while. El bucle for no es un bucle condicionado en Python.
BUCLE while
No hay mucho que decir de la instrucción while en Python: si ya has estudiado la teoría con pseudocódigo y has visto los ejemplos con papercode, estamos hablando de lo mismo, con dos salvedades: solo puedes usar la palabra while, y tienes control de fuga else en caso de que el ciclo use una sentencia break.
Se debe recordar aquí que un bucle abre un nuevo bloque, lo que significa que se debe indentar el bloque, y que el indentado se debe mantener para el mismo bloque. Todo bloque interno estará indentado más a la derecha. Un bloque termina cuando ya no hay mas instrucciones a su mismo nivel de indentado.
La sintaxis para un bucle while en Python es como se muestra a continuación:
while condición :
#bloque de instrucciones
[else:]
#bloque instrucciones por salida normal del ciclo
En Python, los bloques se abren con el caracter dos puntos ( : ), llamado 'colon' en ingles.
La sentencia else es opcional. Si se usa, se activa cada que el bucle while termina normalmente.
Si por algún motivo el ciclo termina abruptamente con una sentencia break, el else no se activa, lo que da la oportunidad de reconocer la forma en que el ciclo termina.
La condición es cualquier valor lógico, o cualquier valor que tenga sentido para Python como un valor lógico.
El ejemplo que sigue muestra un bucle infinito válido en Python, que es interrumpido inmediatamente comienza por una sentencia break, lo que evita que el bloque else se ejecute.
while True :
break;
else:
print("este código es muerto y nunca se corre")
El uso del ciclo while es más evidente con ejemplos.
BUCLE while
No hay mucho que decir de la instrucción while en Python: si ya has estudiado la teoría con pseudocódigo y has visto los ejemplos con papercode, estamos hablando de lo mismo, con dos salvedades: solo puedes usar la palabra while, y tienes control de fuga else en caso de que el ciclo use una sentencia break.
Se debe recordar aquí que un bucle abre un nuevo bloque, lo que significa que se debe indentar el bloque, y que el indentado se debe mantener para el mismo bloque. Todo bloque interno estará indentado más a la derecha. Un bloque termina cuando ya no hay mas instrucciones a su mismo nivel de indentado.
La sintaxis para un bucle while en Python es como se muestra a continuación:
while condición :
#bloque de instrucciones
[else:]
#bloque instrucciones por salida normal del ciclo
En Python, los bloques se abren con el caracter dos puntos ( : ), llamado 'colon' en ingles.
La sentencia else es opcional. Si se usa, se activa cada que el bucle while termina normalmente.
Si por algún motivo el ciclo termina abruptamente con una sentencia break, el else no se activa, lo que da la oportunidad de reconocer la forma en que el ciclo termina.
La condición es cualquier valor lógico, o cualquier valor que tenga sentido para Python como un valor lógico.
El ejemplo que sigue muestra un bucle infinito válido en Python, que es interrumpido inmediatamente comienza por una sentencia break, lo que evita que el bloque else se ejecute.
while True :
break;
else:
print("este código es muerto y nunca se corre")
El uso del ciclo while es más evidente con ejemplos.
EJEMPLO: PATRON DE DIVISIBILIDAD
En el libro Introduction to programming in Python (Sedgewick et al., 2015), el señor Sedgewick muestra un programa que permite visualizar una matriz en pantalla, en la que se presenta un patrón de divisibilidad. La idea es imprimir asteriscos en pantalla cada que un número divida a otro o sea dividido por otro. Aunque Sedgewick usó iteradores for sobre secuencias range, nosotros usaremos en la solución blucles while, dentro del contexto del capítulo. R/ def divisibility_table(n): i=1 while i <= n: j=1 while j <= n: if i% j == 0 or j % i == 0: print('* ', end='') else: print(' ', end='') j= j + 1 print() i = i + 1 Usando n = 6, tenemos: divisibility_table(6) La salida es la que sigue: * * * * * * * * * * * * * * * * * * * * * * * Para n=6, el bucle más externo corre 6 veces. Para el efecto, establecemos una variable i en 1, y abrimos un bucle condicionado para que vaya de 1 hasta n. El bucle interno se ejecuta n veces por cada uno de los ciclos del bucle externo. Dentro del bucle interno, averiguamos por la divisibilidad. Si hay algún tipo de divisibilidad entre el número del bucle externo y el número del bucle interno, dibujamos un asterisco. (‘*’). Si no, dibujamos un espacio en blanco. Cada vez que el bucle interno termina, saltamos de línea y comenzamos con el siguiente número del bucle externo. Tan pronto el bucle externo no cumple con la condición, salimos de él, y terminamos. |
ROMPER BUCLES
Un bucle while termina cuando la condición es falsa.
Sin embargo, hay ciertas situaciones que obligan a hacer rupturas de la ejecución dentro del bucle de forma intencional sin que sea la condición la encargada de terminar el ciclo, por alguna situación de lógica que amerita salida inmediata del bucle.
Para hacerlo, contamos con la sentencia break. Cuando una línea de código alcanza una sentencia break, el bucle termina inmediatamente.
Un bucle while termina cuando la condición es falsa.
Sin embargo, hay ciertas situaciones que obligan a hacer rupturas de la ejecución dentro del bucle de forma intencional sin que sea la condición la encargada de terminar el ciclo, por alguna situación de lógica que amerita salida inmediata del bucle.
Para hacerlo, contamos con la sentencia break. Cuando una línea de código alcanza una sentencia break, el bucle termina inmediatamente.
EJEMPLO: BÚSQUEDA SECUENCIAL EN ARREGLO DESORDENADO
Construya un algoritmo que reciba un arreglo desordenado de datos tipo string, y una cadena que se desea buscar,y devuelva la posición en el arreglo en que se encuentra la cadena buscada. Si la cadena no está, se devuelve -1. R/ def buscar (data , buscado:string)->int: idx = 0 tam = len(data) pos = -1 while idx < tam: if data[idx] == buscado: pos = idx break idx = idx + 1 return pos EXPLICACIÓN. La función recibe como parámetro un arreglo de datos, y un valor a buscar. Se consulta el tamaño del arreglo y se actualiza con ese dato la variable tam. Se inicializa un índice llamada idx para subindicar el arreglo en 0. Avanzaremos en el arreglo usando la condición idx < tam. Dentro del bucle, preguntamos si el dato en la posición idx es el dato buscado. Si no lo es, no entramos al bloque del if, y seguimos adelante en la búsqueda incrementando a idx en 1. Pero si en algún ciclo del bucle encontramos el dato, esto es, data[idx] == buscado, entonces a la variable pos la actualizamos a la posición idx, y podemos salir del bucle inmediatamente con break. No tenemos que seguir buscando más adelante en el arreglo. |
VOLVER A CHEQUEO DE CONDICIÓN DE BUCLE
Algunas veces, necesitamos omitir todo o parte del bloque interno de un bucle.
Por ejemplo, no deseamos considerar un dato concreto, porque no nos da sentido, y pasamos al siguiente.
Otras veces, estamos sondeando una fuente de datos dentro de una ventana de tiempo que no se ha cumplido mientras el bucle está rodando.
También podría pasar que hay que hacer un cálculo solo en ciertas situaciones, mientras que en otras el bloque del bucle no aplica. En prácticamente todos los casos se pueden usar condicionales para evitarlo.
Sin embargo, existe una posibilidad de volver al condicional por medio de una transferencia directa (goto).
A esta transferencia directa muchos lenguajes la manejan con una palabra reservada que normalmente es continue.
Python no es la excepción. Veamos un ejemplo.
Algunas veces, necesitamos omitir todo o parte del bloque interno de un bucle.
Por ejemplo, no deseamos considerar un dato concreto, porque no nos da sentido, y pasamos al siguiente.
Otras veces, estamos sondeando una fuente de datos dentro de una ventana de tiempo que no se ha cumplido mientras el bucle está rodando.
También podría pasar que hay que hacer un cálculo solo en ciertas situaciones, mientras que en otras el bloque del bucle no aplica. En prácticamente todos los casos se pueden usar condicionales para evitarlo.
Sin embargo, existe una posibilidad de volver al condicional por medio de una transferencia directa (goto).
A esta transferencia directa muchos lenguajes la manejan con una palabra reservada que normalmente es continue.
Python no es la excepción. Veamos un ejemplo.
EJEMPLO: LANZAMIENTO DE MONEDA
Cada que se tira una moneda al aire, cae cara con probabilidad del 50% y sello con probabilidad del 50%. Construya un programa Python que lance n veces una moneda, y determine cuántas caras y cuantos sellos cayó la moneda. R/ ANÁLISIS. Se puede usar la librería random para trabajar números aleatorios entre 0 y 1, y definimos que cae cara si el valor mayor a cero, hasta 0.5, y sello si cae otro valor. Se descarta el número cero para equilibrar las posibilidades: dado que la función random( ) genera valores en el rango [0,1), el número 1 nunca sería generado, lo que desbalancearía las oportunidades. Por tal motivo, si un lanzamiento es cero, no lo tenemos en cuenta y volvemos al condicional con continue. from random import random def lanzamientos(n:int) -> int: cara,sello = 0,0 i=1 while i <= n: lanza = random() if lanza == 0: continue if lanza <= 0.5: cara = cara + 1 else: sello = sello + 1 i = i + 1 return (cara,sello) NOTAS ADICIONALES. La función podría ser llamada cuantas veces se quiera, para analizar los resultados tanto como se quiera. Como un ejemplo, se usará 5 series de 10000 lanzamientos de monedas, y una serie de 50000 lanzamientos. print (lanzamientos(10000)) print (lanzamientos(10000)) print (lanzamientos(10000)) print (lanzamientos(10000)) print (lanzamientos(10000)) print (lanzamientos(50000)) haremos una llamada de ejemplo a la función para revisar los resultados. El autor de este texto obtuvo los siguientes resultados. (4997, 5003) (4994, 5006) (4991, 5009) (5156, 4844) (5048, 4952) (24921, 25079) |
TERMINACIÓN NORMAL O ANORMAL DE BUCLE
Un bucle while termina cuando la condición es falsa, o cuando usamos una transferencia break.
En el primer caso, hablamos de una terminación normal, y en el segundo de una terminación abrupta o anormal.
Cuando salimos de un bucle, no sabemos cuál fue la forma de terminación.
Python tiene una característica interesante dentro de su bucle while, que le permite identificar si un bucle terminó normalmente por la condición.
La característica es una sentencia else luego del bucle. Esta sentencia no se activa si el rompimiento fue debido a un break, lo que permite identificar el modo de salida.
Un bucle while termina cuando la condición es falsa, o cuando usamos una transferencia break.
En el primer caso, hablamos de una terminación normal, y en el segundo de una terminación abrupta o anormal.
Cuando salimos de un bucle, no sabemos cuál fue la forma de terminación.
Python tiene una característica interesante dentro de su bucle while, que le permite identificar si un bucle terminó normalmente por la condición.
La característica es una sentencia else luego del bucle. Esta sentencia no se activa si el rompimiento fue debido a un break, lo que permite identificar el modo de salida.
EJEMPLO: NIVEL DE PALINDROMÍA
Construya un algoritmo que reciba una palabra y determine su nivel de palindromía. Una palabra es palíndroma si se lee igual de derecha a izquierda que de izquierda a derecha. Si los caracteres extremos son diferentes, el nivel de palindromía es 0.0. Si la cadena es palindroma, se dice que el nivel de palindromía es 1.0. Si la cadena es palindroma parcialmente, el nivel es el número de caracteres iguales, dividido la mitad de la longitud de la cadena. Una cadena vacía se define como una cadena palíndroma. R/ def nivel_palindromia (s:str)->float: if len(s) == 0: return 1.0 i = 0; j = len(s)-1 while i < j: if s[i] != s[j] : break else: i += 1 j -= 1 else: return 1.0 #termina normal el while, palindromía total if i == 0: return 0.0 #terminación break diferencia en extremos else: #se calcula el nivel de palindromía nivel = i / len(s) / 2 return 1.0 #terminación break es palindromía total el break sólo se da por el hallazgo de dos caracteres diferentes, y nos rompe el ciclo. El else de while contiene return 1.0. Eso se debe a que terminó normalmente, lo que indica que los caracteres se leen igual de izquierda a derecha, que de derecha a izquierda. El if al terminar el while se ejecuta por las demás razones, que implican que no hay palindromía completa. En el caso que i sea cero(0), significa que los caracteres extremos son diferentes, y por lo tanto el nivel es 0.0. En el caso que i sea diferente de cero, debemos calcular el nivel según se explica en la especificación del problema. |
BUCLE ITERADOR DE SECUENCIAS for
La otra estructura bucle en Python es un bucle no condicionado iterador de colecciones.
La palabra clave Python para este iterador no condicionado es for, y, al igual que el while, hay control de fuga else en caso de que el ciclo use una sentencia break.
Dado que un bucle for abre un nuevo bloque Python, se debe hacer indentación a la derecha, y mantenerse indentado.
La sintaxis para un bucle iterador de colecciones for en Python es como se muestra a continuación:
for elemento in colección:
#bloque de instrucciones
[else:]
#bloque de instrucciones por salida normal del ciclo
La sentencia else es opcional para el iterador for no condicionado, y en este aspecto trabaja exactamente igual que el else de un while. Si se usa, se activa cada que el bucle for termina normalmente su recorrido sobre los elementos de la colección controladora. Si por algún motivo el ciclo termina abruptamente con una sentencia break, el else no se activa, lo que da la oportunidad de reconocer la forma en que el ciclo termina.
No es posible crear una condición booleana de fin para un for como en el caso de un ciclo while. La condición es automática y restrictiva: alcanzar el fin de la colección. La otra alternativa de terminación es romper el bucle con un break.
La colección en un bucle for de Python puede ser cualquiera entre listas, tuplas, diccionarios.
También se pueden crear funciones que son usadas como generadoras de elementos: cada que el ciclo for va por el siguiente elemento, este se genera desde una función. Eso permitiría crear colecciones personalizadas 'al vuelo', e incluso podríamos hacer ciclos infinitos con una sentencia de bucle for.
ITERADORES.
Las colecciones de elementos pueden ser utilizadas potencialmente por el operador for. Para tal efecto, deberán ser objetos iterables. Un objeto es iterable, si está preparado para ser iterado.
Suena lógico, pero no todas las colecciones son necesariamente iterables.
Los objetos colección tienen un atributo llamado ___iter__( ). Un objeto entero, por ejemplo no es iterable, ya que no representa una colección.
Por otro lado, una lista es iterable, y contiene un atributo denominado __iter__( ).
La librería __builtins__ contiene una función llamada iter(), que puede ser usado sobre una colección, y se encarga de llamar el atributo __iter__( ). Si el atributo no está disponible, sale un error. Pero si la colección es iterable, se devuelve una referencia al objeto iterador que es capaz de recorrer uno a uno los elementos de la colección.
Ese es el objeto que puede ser asociado a una sentencia for. Hecha la asociación, un bucle for podrá hacer su trabajo.
Cada vez que una colección es referenciada por un for, se llama el aributo __iter__( ) para recorrer la colección de datos.
El objeto iterador facilita el método __next__( ).
El método __next__( ) entrega el siguiente elemento al actual cuando es invocado. No hay reversas en este recorrido. La primera vez, el método __next_ ( ) entrega el primer elemento; y cuando no hay más elementos en una colección, el método levanta el error StopIteration, para indicar que ya no hay más elementos disponibles.
La otra estructura bucle en Python es un bucle no condicionado iterador de colecciones.
La palabra clave Python para este iterador no condicionado es for, y, al igual que el while, hay control de fuga else en caso de que el ciclo use una sentencia break.
Dado que un bucle for abre un nuevo bloque Python, se debe hacer indentación a la derecha, y mantenerse indentado.
La sintaxis para un bucle iterador de colecciones for en Python es como se muestra a continuación:
for elemento in colección:
#bloque de instrucciones
[else:]
#bloque de instrucciones por salida normal del ciclo
La sentencia else es opcional para el iterador for no condicionado, y en este aspecto trabaja exactamente igual que el else de un while. Si se usa, se activa cada que el bucle for termina normalmente su recorrido sobre los elementos de la colección controladora. Si por algún motivo el ciclo termina abruptamente con una sentencia break, el else no se activa, lo que da la oportunidad de reconocer la forma en que el ciclo termina.
No es posible crear una condición booleana de fin para un for como en el caso de un ciclo while. La condición es automática y restrictiva: alcanzar el fin de la colección. La otra alternativa de terminación es romper el bucle con un break.
La colección en un bucle for de Python puede ser cualquiera entre listas, tuplas, diccionarios.
También se pueden crear funciones que son usadas como generadoras de elementos: cada que el ciclo for va por el siguiente elemento, este se genera desde una función. Eso permitiría crear colecciones personalizadas 'al vuelo', e incluso podríamos hacer ciclos infinitos con una sentencia de bucle for.
ITERADORES.
Las colecciones de elementos pueden ser utilizadas potencialmente por el operador for. Para tal efecto, deberán ser objetos iterables. Un objeto es iterable, si está preparado para ser iterado.
Suena lógico, pero no todas las colecciones son necesariamente iterables.
Los objetos colección tienen un atributo llamado ___iter__( ). Un objeto entero, por ejemplo no es iterable, ya que no representa una colección.
Por otro lado, una lista es iterable, y contiene un atributo denominado __iter__( ).
La librería __builtins__ contiene una función llamada iter(), que puede ser usado sobre una colección, y se encarga de llamar el atributo __iter__( ). Si el atributo no está disponible, sale un error. Pero si la colección es iterable, se devuelve una referencia al objeto iterador que es capaz de recorrer uno a uno los elementos de la colección.
Ese es el objeto que puede ser asociado a una sentencia for. Hecha la asociación, un bucle for podrá hacer su trabajo.
Cada vez que una colección es referenciada por un for, se llama el aributo __iter__( ) para recorrer la colección de datos.
El objeto iterador facilita el método __next__( ).
El método __next__( ) entrega el siguiente elemento al actual cuando es invocado. No hay reversas en este recorrido. La primera vez, el método __next_ ( ) entrega el primer elemento; y cuando no hay más elementos en una colección, el método levanta el error StopIteration, para indicar que ya no hay más elementos disponibles.
EJEMPLO: MÍNIMO DE LAS POSICIONES IMPARES
Dada una lista de valores, determine el valor mínimo de las posiciones impares. R/ ANÁLISIS. La mínima posición se puede evaluar usando la función min de Python. Sin embargo, nos tocaría construir una lista nueva con los valores de las posiciones impares. Ese caso es más claro con un comprehension que veremos más adelante. Por el momento, compararemos las posiciones impares. Dado que recorreremos las posiciones impares, podemos recorrerlas todas y llevar contadores que nos indique la imparidad. Pero no es necesario si usamos un range. def minimo_impares(values:list)->float: menor = float("+inf") for pos in range(1,len(values),2): if values[pos] < menor: menor = values[pos] return menor |
'COMPREHENSIONS'
Las comprehensiones es una forma de generar una lista de datos usando una sintaxis especial de Python. Una comprehensión es un bucle generatriz, rn la que por cada iteración e un bucle iterador, se puede dejar un valor como elemento de una lista.
Para surtir el efecto, se encierra la comprehension entre corchetes [].
El iterador es disconexo de la expresión, y solo sirve para iterar sobre los valores de la secuencia iterada, pero pone a disposición el elemento referenciador por si se desea usar en la expresión.
La sintaxis python para una comprehension es simple:
expresión for elemento in colección
Por si sola, la comprehension generará un error de sintaxis.
Uso de ‘comprehensions’ para generar listas.
Si la comprehension está entre corchetes, se genera una lista. Los valores de los elementos de la lista corresponden a la reducción e la expresión que aparece en la izquierda.
[expresión for elemento in colección]
Por ejemplo, podríamos unara una iteración para llemar una lista con elementos 0.
>>> [0 for i in range(10)]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
Note que, a pesar de que el iterador for itera la secuencia 0 a 9, la expresión generadora es solo el número 0. Por tal motivo, para cada iteración, se creará un nuevo elemento de la lista con ese valor 0.
La variable i queda al alcance de la expresión. Por tal motivo, podríamos llenar la lista con números entre 0 y 9, así:
>>> [i for i in range(10)]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>
Ahora suponga que usamos una expresión más compleja. Por ejemplo, queremos generar una lista con los caracteres ascii:
>>> [chr(i) for i in range(256)]
['\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07', '\x08', '\t', '\n', '\x0b', '\x0c', '\r', '\x0e', '\x0f', '\x10', '\x11', '\x12', '\x13', '\x14', '\x15', '\x16', '\x17', '\x18', '\x19', '\x1a', '\x1b', '\x1c', '\x1d', '\x1e', '\x1f', ' ', '!', '"', '#', '$', '%', '&', "'", '(', ')', '*', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?', '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', ']', '^', '_', '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~', '\x7f', '\x80', '\x81', '\x82', '\x83', '\x84', '\x85', '\x86', '\x87', '\x88', '\x89', '\x8a', '\x8b', '\x8c', '\x8d', '\x8e', '\x8f', '\x90', '\x91', '\x92', '\x93', '\x94', '\x95', '\x96', '\x97', '\x98', '\x99', '\x9a', '\x9b', '\x9c', '\x9d', '\x9e', '\x9f', '\xa0', '¡', '¢', '£', '¤', '¥', '¦', '§', '¨', '©', 'ª', '«', '¬', '\xad', '®', '¯', '°', '±', '²', '³', '´', 'µ', '¶', '·', '¸', '¹', 'º', '»', '¼', '½', '¾', '¿', 'À', 'Á', 'Â', 'Ã', 'Ä', 'Å', 'Æ', 'Ç', 'È', 'É', 'Ê', 'Ë', 'Ì', 'Í', 'Î', 'Ï', 'Ð', 'Ñ', 'Ò', 'Ó', 'Ô', 'Õ', 'Ö', '×', 'Ø', 'Ù', 'Ú', 'Û', 'Ü', 'Ý', 'Þ', 'ß', 'à', 'á', 'â', 'ã', 'ä', 'å', 'æ', 'ç', 'è', 'é', 'ê', 'ë', 'ì', 'í', 'î', 'ï', 'ð', 'ñ', 'ò', 'ó', 'ô', 'õ', 'ö', '÷', 'ø', 'ù', 'ú', 'û', 'ü', 'ý', 'þ', 'ÿ']
>>>
Por cada iteración, podemos usar el valor de i para generar un caracter. Esto significa que la complejidad en la generación del valor para la lista puede llevarse a cualquier nivel.
Uso de ‘comprehensions’ para generar listas anidadas.
Dado que una comprehension acepta una expresión, la expresión podría ser otra comprehension.
Eso permitiría hacer anidamientos con listas.
Por ejemplo, suponga que desea generar un conjunto de listas parciales en el rango 0 a 5 de posibles valores.
>>> [[j for j in range(1,i)] for i in range(1,6)]
[[], [1], [1, 2], [1, 2, 3], [1, 2, 3, 4]]
Guardando generadores de iteraciones para uso posterior.
Si la expresión está entre paréntesis, o se pasa como parámetro de una función, se entrega un objeto generador. Este objeto generador se comporta como una secuencia, en la cual se posterga la evaluación.
(expresión for elemento in colección)
Un generador permite ser iterado por medio del método __next__( ), y cuyo uso se simplifica por el uso de la función next( ) disponible en __builtins__. Debido a esto, un generador puede sr almacenado en memoria en cualquier tipo de estructura para ser usado.
Muchas funciones pueden usar los generadores que se les entregan, pues en realidad, se comportan como secuencias que pueden ser iteradas normalmente.
Por ejemplo, para sumar los cuadrados de los números en el rango 100 a 200, tenemos:
>>> sum(i*i for i in range(100,201))
2358350
>>>
La comprehension pudo haber sido almacenada en una variable para uso posterior:
>>> x=(i*i for i in range(100,201))
>>> sum(x)
2358350
>>>
Las comprehensiones es una forma de generar una lista de datos usando una sintaxis especial de Python. Una comprehensión es un bucle generatriz, rn la que por cada iteración e un bucle iterador, se puede dejar un valor como elemento de una lista.
Para surtir el efecto, se encierra la comprehension entre corchetes [].
El iterador es disconexo de la expresión, y solo sirve para iterar sobre los valores de la secuencia iterada, pero pone a disposición el elemento referenciador por si se desea usar en la expresión.
La sintaxis python para una comprehension es simple:
expresión for elemento in colección
Por si sola, la comprehension generará un error de sintaxis.
Uso de ‘comprehensions’ para generar listas.
Si la comprehension está entre corchetes, se genera una lista. Los valores de los elementos de la lista corresponden a la reducción e la expresión que aparece en la izquierda.
[expresión for elemento in colección]
Por ejemplo, podríamos unara una iteración para llemar una lista con elementos 0.
>>> [0 for i in range(10)]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
Note que, a pesar de que el iterador for itera la secuencia 0 a 9, la expresión generadora es solo el número 0. Por tal motivo, para cada iteración, se creará un nuevo elemento de la lista con ese valor 0.
La variable i queda al alcance de la expresión. Por tal motivo, podríamos llenar la lista con números entre 0 y 9, así:
>>> [i for i in range(10)]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>
Ahora suponga que usamos una expresión más compleja. Por ejemplo, queremos generar una lista con los caracteres ascii:
>>> [chr(i) for i in range(256)]
['\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07', '\x08', '\t', '\n', '\x0b', '\x0c', '\r', '\x0e', '\x0f', '\x10', '\x11', '\x12', '\x13', '\x14', '\x15', '\x16', '\x17', '\x18', '\x19', '\x1a', '\x1b', '\x1c', '\x1d', '\x1e', '\x1f', ' ', '!', '"', '#', '$', '%', '&', "'", '(', ')', '*', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?', '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', ']', '^', '_', '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~', '\x7f', '\x80', '\x81', '\x82', '\x83', '\x84', '\x85', '\x86', '\x87', '\x88', '\x89', '\x8a', '\x8b', '\x8c', '\x8d', '\x8e', '\x8f', '\x90', '\x91', '\x92', '\x93', '\x94', '\x95', '\x96', '\x97', '\x98', '\x99', '\x9a', '\x9b', '\x9c', '\x9d', '\x9e', '\x9f', '\xa0', '¡', '¢', '£', '¤', '¥', '¦', '§', '¨', '©', 'ª', '«', '¬', '\xad', '®', '¯', '°', '±', '²', '³', '´', 'µ', '¶', '·', '¸', '¹', 'º', '»', '¼', '½', '¾', '¿', 'À', 'Á', 'Â', 'Ã', 'Ä', 'Å', 'Æ', 'Ç', 'È', 'É', 'Ê', 'Ë', 'Ì', 'Í', 'Î', 'Ï', 'Ð', 'Ñ', 'Ò', 'Ó', 'Ô', 'Õ', 'Ö', '×', 'Ø', 'Ù', 'Ú', 'Û', 'Ü', 'Ý', 'Þ', 'ß', 'à', 'á', 'â', 'ã', 'ä', 'å', 'æ', 'ç', 'è', 'é', 'ê', 'ë', 'ì', 'í', 'î', 'ï', 'ð', 'ñ', 'ò', 'ó', 'ô', 'õ', 'ö', '÷', 'ø', 'ù', 'ú', 'û', 'ü', 'ý', 'þ', 'ÿ']
>>>
Por cada iteración, podemos usar el valor de i para generar un caracter. Esto significa que la complejidad en la generación del valor para la lista puede llevarse a cualquier nivel.
Uso de ‘comprehensions’ para generar listas anidadas.
Dado que una comprehension acepta una expresión, la expresión podría ser otra comprehension.
Eso permitiría hacer anidamientos con listas.
Por ejemplo, suponga que desea generar un conjunto de listas parciales en el rango 0 a 5 de posibles valores.
>>> [[j for j in range(1,i)] for i in range(1,6)]
[[], [1], [1, 2], [1, 2, 3], [1, 2, 3, 4]]
Guardando generadores de iteraciones para uso posterior.
Si la expresión está entre paréntesis, o se pasa como parámetro de una función, se entrega un objeto generador. Este objeto generador se comporta como una secuencia, en la cual se posterga la evaluación.
(expresión for elemento in colección)
Un generador permite ser iterado por medio del método __next__( ), y cuyo uso se simplifica por el uso de la función next( ) disponible en __builtins__. Debido a esto, un generador puede sr almacenado en memoria en cualquier tipo de estructura para ser usado.
Muchas funciones pueden usar los generadores que se les entregan, pues en realidad, se comportan como secuencias que pueden ser iteradas normalmente.
Por ejemplo, para sumar los cuadrados de los números en el rango 100 a 200, tenemos:
>>> sum(i*i for i in range(100,201))
2358350
>>>
La comprehension pudo haber sido almacenada en una variable para uso posterior:
>>> x=(i*i for i in range(100,201))
>>> sum(x)
2358350
>>>
EJEMPLO: MÍNIMO DE LAS POSICIONES IMPARES
Dada una lista de valores, determine el valor mínimo de las posiciones impares. R/ Dado que recorreremos las posiciones impares, podemos usar una comprehension, y aplicar la función min( ) de python a la comprehension. def minimo_impares(values:list)->list: x = (values[pos] for pos in range(1,len(values),2)) return min(x) al recorrer las posiciones impares, vamos extrayendo en la comprehension el valor de esas posiciones en el arreglo values, y finalmente ese generador queda a disposición de la función min, que se encarga de buscar el mínimo entre los valores. La función pudo haberse escrito más simple, sin el uso de la variable intemedia x. def minimo_impares(values:list)->list: return min(values[pos] for pos in range(1,len(values),2)) |
SESIÓN #8 DE EJERCITACIÓN:
BIFURCACIÓN CÍCLICA: while-else, for-else
- Patrón de dígitos I.
Construya una función Python que use bucles y la instrucción print(),generar el siguiente patrón de impresión.
0123456789
01234567
012345
0123
01 - Patrón de dígitos II.
Construya una función Python que use bucles y la instrucción print(),generar el siguiente patrón de impresión.
0123456789
012345678
01234567
0123456
012345
01234
0123
012
01
0 - Patrón de dígitos III.
Construya una función Python que use bucles y la instrucción print(),generar el siguiente patrón de impresión.
9876543210123456789
765432101234567
54321012345
3210123
101
0 - Patrón de dígitos IV.
Construya una función Python que use bucles y la instrucción print(),generar el siguiente patrón de impresión.
1
121
12321
1234321
123454321
12345654321
1234567654321
123456787654321
12345678987654321 - Patrón rectángulo con asteriscos.
Construya una función Python que use bucles y la instrucción print(), para generar un rectángulo de R por C asteriscos, del que sólo se grafican los bordes. La función Python recibe como parámetros el número de caracteres de ancho y el número de caracteres de alto. Por ejemplo,
para R = 4, C = 10, se imprime
**********
* *
* *
********** - Patrón de dígitos V.
Construya una función Python que use bucles y la instrucción print(),generar el siguiente patrón de impresión. El tamaño de los lados debe ser paramétrico. Por ejemplo para a=7,l=18, la salida es
111111111111111111
2 2
3 3
4 4
5 5
777777777777777777 - Patrón de dígitos VI.
Construya una función Python que use bucles y la instrucción print(),generar el siguiente patrón de impresión. El número de filas debe ser paramétrico. Por ejemplo, para f=9, la salida es:
1
23
456
7890
12345
678901
2345678
90123456
789012345 - Patrón de letras.
Construya una función Python que use bucles y la instrucción print(),generar el siguiente patrón de impresión. El número de filas debe ser paramétrico. Por ejemplo, para f=8, la salida es:
A
BC
DEF
GHIJ
KLMNO
PQRSTU
VWXYZAB
CDEFGHIJ - Histograma vertical.
Dada una lista con valores que representan un histograma, construya un histograma vertical de astericos. Por ejemplo,
para [8,5,3,2,1,6,3,1]
la salida es:
*
*
* *
* * *
* * *
* * * * *
* * * * * *
* * * * * * * * - Histograma horizontal.
Dada una lista con valores que representan un histograma, construya un histograma horizontal usando caracteres. Por ejemplo,
para [8,5,3,2,1,6,3,1]
la salida es:
* * * * * * * *
* * * * *
* * *
* *
*
* * * * * * *
* * *
* - Patrón Triángulo con asteriscos.
Construya una función Python que use bucles y la instrucción print(), para generar un triángulo basado en C columnas iniciales.
Por ejemplo, para C = 10, se imprime
**********
* *
* *
* *
* *
* *
* *
* *
**
* - Patrón Triángulo equilátero con asteriscos.
Construya una función Python que use bucles y la instrucción print(), para generar un triángulo basado en C asteriscos de base.
Por ejemplo, para C = 10, se imprime
**
* *
* *
* *
**********
para C = 9, se imprime
*
* *
* *
* *
********* - Patrón Triángulo y cuadrado con asteriscos.
Construya una función Python que use bucles y la instrucción print(), para generar un triángulo y un rectángulo con B asteriscos de base.
Por ejemplo,
para B = 9, se imprime
* *********
* * * *
* * * *
* * * *
********* ********* - Minesweeper.
Escriba una función python que dados dos valores m y n que representan el número de filas y de columnas en una matriz, y dado p que representa la probabilidad que en una posición haya una bomba, presente la matriz usando asteriscos para las bombas, y puntos para los espacios libres. Llene los espacios vacíos con el número de bombas vecinas.
Un ejemplo de salida para m = 3, n = 4, sería
* * . . . * * 1 0 0
. . . . . 3 3 2 0 0
. * . . . 1 * 1 0 0
(Sedgewick & Wayne, 2017) - Triángulo de Pascal.
Construya una función Python que use bucles y la instrucción print(), para generar un triángulo de Pascal de las filas 0 a la 5.
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1 - Tabla de multiplicar.
Dados un número entero inicial, y uno final, elabore una función Python que imprima una tabla de multiplicar donde cada multiplicando como multiplicador se da en rangos. Por ejemplo
Para el rango 7 a 12, y rango 1 a 9, el resultado es:
7 8 9 10 11 12
1 7 8 9 10 11 12
2 14 16 18 20 22 24
3 21 24 27 30 33 36
4 28 32 36 40 44 48
5 35 40 45 50 55 60
6 42 48 54 60 66 72
7 49 56 63 70 77 84
8 56 64 72 80 88 96
9 63 72 81 90 99 108 - Calendario del mes para consola.
El siguiente código Python calcula el número del día de la semana para la fecha 1 de agosto de 2020. El resultado es 6, que corresponde al sábado. El día domingo sería el 0.
import datetime
int(datetime.date(2020,8,1).strftime('%w'))
Construya una función Python que imprima el calendario de un mes cualquiera. Por ejemplo, el calendario para el mes de agosto de 2020 es:
D L M W J V S
1
2 3 4 5 6 7 8
9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 29
30 31 - Cuadrado espiral.
Construya una función Python que use bucles y la instrucción print(), para generar un cuadrado de N x N con enteros en espiral comenzando por 0 en la esquina superior izquierda. Por ejemplo,
si N=5
1 2 3 4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9
Si N = 6
1 2 3 4 5 6
20 21 22 23 24 7
19 32 33 34 25 8
18 31 36 35 26 9
17 30 29 28 27 10
16 15 14 13 12 11 - Graficador ASCII de funciones.
Se desea un graficador de funciones en dos dimensiones, que reciba un rango de valores x como tupla (x1,x2), una función matemática polinómica escrita en una cadena (que sea una expresión matemática válida Python). El tamaño del plano en el eje x es el rango dado, pero el tamaño en el eje Y es calculado con un primer barrido de la función sobre los valores del eje X. El plano cartesiano es básico, y comienza en las coordenadas (0,0), y se sabe que el graficador no graficará datos negativos de x, ni datos negativos de y. Cada punto del graficador es un caracter, y se grafica por redondeo al punto (x,y) más cercano.
Construya una función Python que, dados los datos solicitados, grafique la función y la despliegue en pantalla como caracteres. - Generar número en cadena.
Dado un número de dígitos y un dígito inicial, generar un nuevo número. Un tercer parámetro de dirección, indica si la generación es ascendente o descendente: 0 ascendente, 1 descendente. La salida deberá ser una cadena de caracteres (string).
Por ejemplo,
para n= 4, d=3, dir=0, devolver "3456"
para n=20, d=7, dir=1, devolver "76543210987654321098"
para n=20, d=7, dir=0, devolver "78901234567890123456" - Multiplicación del Peatón Ruso. Este es un algoritmo sobre multiplicación, planteado en el libro Mathematical Curiosities de Posamenter & Lehmann, 2014. Elabore una función en pseudocódigo que permita multiplicar dos números cualquiera a y b, según el ejemplo:
a = 73, b = 82
a * 2 = 146, b / 2 = 41
146 * 2 = 292, 41 / 2 = 20 (excluye fracción)
292 * 2 = 584, 20 / 2 = 10
584 * 2 = 1168, 10 / 2 = 5
1168 * 2 = 2336, 5 / 2 = 2 (excluye fracción)
2336 * 2 = 4672, 2 / 2 = 1
Cuando la división sea 1, se suman todos aquellos valores obtenidos de multiplicar por 2, siempre y cuando la división por 2 del compañero tenga como resultado un número impar.
Si el número inicial b era impar, también se suma el primer a.
En este ejemplo, 73 * 82 = 146 + 1168 + 4672 = 5986
Otro ejemplo:
a = 15, b = 15
a * 2 = 30, b / 2 = 7
a * 2 = 60, b / 2 = 3
a * 2 = 120, b / 2 = 1
Note que en este caso todas las divisiones son impares. Incluso b inicial es impar, por lo que a inicial también se suma.
En este ejemplo, 15 * 15 = 15 + 30 + 60 + 120 = 225 - Suma autogenerada con dígito ascendente y ‘reset’ .
Dado un número de términos t, y un número entero positivo de restablecimiento r, cree una función en pseudocódigo que determine el resultado de evaluar la serie que se genera como se muestra en el ejemplo.
Suponga t = 10 y r = 8.
La serie de t = 10 términos será:
1 + 23 - 456 + 7890 - 12345 + 678901 – 2345678 + 90123456 – 7 + 89. El total de términos a generar es t, y la serie recomienza en el término r. - Suma autogenerada con dígito descendente y ‘reset’.
Dado un número de términos t, y un número entero positivo de restablecimiento r, cree una función en pseudocódigo que determine el resultado de evaluar la serie que se genera como se muestra en el ejemplo.
Suponga t = 10 y r=8.
La serie de t=10 términos será:
9 + 87 – 654 + 8310 – 98765 + 432109 – 8765432 + 10987654 – 3 - 21
Note que cada número se forma restando digitos, entre 9 y 0.
El total de términos a generar es t, y la serie recomienza en el término r. - Teorema de Liouville. El teorema de Liouville dice que la suma de los cubos de la cantidad de divisores que tiene cada uno de los divisores de un número n dado, es igual al cuadrado de la suma de esas mismas cantidades. Suponga que n es 12.
Divisores de 12 son: 1,2,3,4,6 y 12.
el 1 tiene 1 divisor (1)
el 2 tiene 2 divisores (1,2)
el 3 tiene 2 divisores (1,3)
el 4 tiene 3 divisores (1,2,4)
el 6 tiene 4 divisores (1,2,3,6)
el 12 tiene 6 divisores (1,2,3,4,6,12)
La suma 13 + 23 + 23 + 33 + 43 + 63 = 324
La suma 1 + 2 + 2 + 3 + 4 + 6 = 18, elevada al cuadrado 182 = 324
(Posamentier & Lehmann, 2004, pag. 95).
Construya una función Python que determine para un número n dado como parámetro, la suma de los conteos de los divisores de los divisores de n, y su cuadrado. La función devolverá una tupla. Para el caso de n=12, la función devuelve (18 , 324) - Factores primos.
Todo número entero, se puede descomponer en factores primos.
Por ejemplo,
13 = 13 (es primo, y su único factor es él mismo)
2678 = 2 x 13 x 103
249 = 3 x 83
714 = 2 x 3 x 7 x 17
9792 = 2 x 2 x 2 x 2 x 2 x 2 x 3 x 3 x 17
71 = 71
Construya una función Python para determinar los factores primos de un número dado. - Números con mayor cantidad de factores primos.
Todo número entero, se puede descomponer en factores primos.
Ver problema anterior.
Construya una función Python para determinar, en un rango de valores [a,b], el número que mayor cantidad de factores primos tiene. - Distribución de factores primos.
Para un rango [a,b] de números enteros, determine todos sus factores primos, y emita una distribución porcentual. Esto es, cuente cuantas veces está presente, en general entre todos los números, cada uno de los factores primos que halló, y determine su porcentaje frente al número total de primos utilizados. No tenga en cuenta los números que ya son primos y no se pueden descomponer. - Suma de factores primos.
Dado que un número se puede descomponer en sus factores primos (ver problema titulado “Factores primos”), construya una función en Python que determine la suma de los factores primos de un número. - Números Ruth-Aaron.
Dados dos números enteros positivos consecutivos, donde la suma de sus factores primos da el mismo valor, se les denomina a esos dos números, números Ruth-Aaron.
Por ejemplo, los números consecutivos
714 = 2 x 3 x 7 x 17 con 2 + 3 + 7 + 17 = 29
715 = 5 x 11 x 13 con 5 + 11 + 13 = 29
(Posamentier, Lehmann, 2014, pag 46)
Construya una función Python que determine para un rango de enteros dados, los pares de números Ruth-Aaron. - Números Ruth-Aaron sin factores repetidos.
Considere el problema“Números Ruth-Aaron”, donde algunos de los factores pueden estar repetidos. Construya una función Python que determine para un rango de enteros dados, los pares de números Ruth-Aaron que no contienen factores internos repetidos.
Por ejemplo, 24 y 25 son números Ruth-Aaron con factores repetidos (24 = 2 x 2 x 2 x 3 y 25 = 5 x 5), y por lo tanto no podrán ser tenidos en cuenta en la búsqueda, mientras que 714 y 715 que no contienen factores repetidos, sí tienen que ser considerados en la búsqueda. - Palindromías altas para la suma de dígitos invertidos.
En su libro Mathematical Curiosities, de 2014, Alfred Posamentier nos enseña que, partir de un número entero positivo cualquiera, se puede generar un número palíndromo si se invierten sus dígitos para obtener otro número, el que, finalmente, se le suma al número inicial. Si el resultado de la suma no es palíndromo, se repite el proceso desde dicho resultado.
Ejemplos:
23+32=55 (pasos hasta palindromía = 1)
75+57=132, 132+231=363 (pasos hasta palindromía = 2)
86+68=154, 154+451=605, 605+506=1111 (pasos hasta palindromía = 3)
Nota: Algunos números, cuando se procesan con este algoritmo, nunca llegan a un palíndromo, como es el caso de los números 196, 295, 394, entre otras excepciones.
Construya un programa Python que determine para números enteros positivos en un rango de dos valores dados, agrupaciones de números según el número de pasos que requieran para llegar a un palíndromo. Para aquellos casos en los que no se presenta recurrencia, controle su algoritmo paa no quedarse en un bucle infinito. - Lista de términos Fibonacci.
Elabore una función en Python llamada fibonacci_numbers(n), que liste los primeros n números de la secuencia de fibonacci. - N-esimo término de Fibonacci.
Elabore una función en Python llamada fibonacci(x), que use un bucle para determinar el término enésimo de la secuencia de fibonacci. La semilla de la secuencia es 0,1, que son los dos primeros términos. Los números que siguen se generan sumando los dos números anteriores. Los primeros términos son
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ... Por ejemplo,
para x = 1, la función devuelve 1
para x = 4, la función devuelve 5
para x = 9, la función devuelve 55 - Derivada de polinomio.
La derivada de un polinomio
Cn X^n + Cn-1 X^(n-1) + … + C1X + C0
se define como
(n)CnX(n-1) + (n-1)Cn-1X^(n-2) + … + C1 + 0
Construya una función Python que reciba una lista con los coeficientes de un polinomio, y un valor para x, y halle su derivada evaluada en x. La posición 0 de la lista contiene el término independiente, C0, la posición uno el término C1, y así sucesivamente. - Determinar si es perfecto.
Elabore una función Python llamada es_perfecto(), que determine si un número es perfecto. Un número se considera perfecto si la suma de todos sus divisores propios da el mismo número. Por ejemplo, el número 6 es perfecto, porque 1 + 2 + 3 = 6. - Perfectos en rango.
Elabore una función Python que determine los números perfectos que hay entre 1 y n, dado como parámetro. La lista de números deberá devolverse como una lista Python. Un número se considera perfecto si la suma de todos sus divisores propios da el mismo número. Por ejemplo, el número 6 es perfecto, porque 1 + 2 + 3 = 6. Tenga en cuenta que no son muchos los números perfectos conocidos, por lo que n deberá ser grande cuando haga sus pruebas, y podrá necesitar buen poder computacional y tiempo. Si es posible, determina cuántos números perfectos hay en los primeros 100 millones de números naturales. - Cajero ideal I.
Un cajero se considera ideal, si entrega la menor cantidad de billetes posible. Construya una función Python que, dado un monto de dinero, determine la cantidad de billetes de cada denominación posible. Las denominaciones posibles vienen dadas en una lista que se entrega junto con el monto. La función devuelve una lista de tuplas, donde cada tupla representa el monto y el número de billetes.Por ejemplo,
para 235000, y [50000, 20000, 10000, 5000], se devuelve [(50000,4),(20000,1),(10000,1),(5000,1)] - Cajero ideal II.
Un cajero se considera ideal, si entrega la menor cantidad de billetes posible. Construya una función Python que, dado un monto de dinero, determine la cantidad de billetes de cada denominación posible. Las denominaciones posibles vienen dadas en una lista que se entrega junto con el monto. La función devuelve una lista de tuplas, donde cada tupla representa el monto y el número de billetes.Se debe garantizar que al menos hay un billete de cada una de las denominaciones. Por ejemplo,
para 235000, y [50000, 20000, 10000], se devuelve [(50000,4),(20000,1),(10000,1),(5000,1)] - Dividir con restas.
Elabore una función Python llamada divide(), que permita dividir dos números a y b, usando solo restas. La función devuelve el cociente y el residuo como una tupla. Por ejemplo:
si a=40 y b=8: a/b = 40-8=32. 32-8=24, 24-8=16. 16-8=8. 8-8=0. Devolver (5 , 0)
si a=8 y b=3: 8-3=5. 5-3=2. Devolver (2 , 2).
si a=100 b=31: 100-31=69. 69-31=38. 38-31=7. Devolver(3 , 7) - Persistencia multiplicativa.
Escriba una función en Python que determine la persistencia multiplicativa de un número, que es el número de veces que usted tiene que multiplicar los dígitos de un número para que el resultado tenga un solo dígito. Por ejemplo:
para 39, 3*9=27, 2*7=14, 1*4=4; devuelve 3.
para 999, 9*9*9=729, 7*2*9=126, 1*2*6=12, 1*2=2; devuelve 4.
para 4; devuelve 0.
para 25, 2*5=10, 1*0=0; devuelve 2.
(Codewars https://www.codewars.com/kata/55bf01e5a717a0d57e0000ec/) - Potencia usando multiplicaciones.
Elabore una función Python llamada pow(), que permita elevar un número b real a una potencia entera positiva p, usando solo multiplicaciones. Por ejemlpo:
si b=4.5 y p=3. Bp = 4.53 = 4.5 x 4.5 x 4.5 = 91.125 - Suma de divisores.
Elabore una función Python que halle la suma de los divisores exactos de un número dado. Por ejemplo:
para 45, la suma es 1 + 3 + 5 + 9 = 15
para 17, la suma es 1
para 36, la suma es 1 + 2 + 3 + 4 + 6 + 9 = 25 - Determinar si un número es primo.
Elabore una función Python llamada es_primo(), que determine si un número es o no, primo. Un número es primo si es solo divisible por él mismo y por uno. Por ejemplo, Los números primos menores que 50 son los siguientes: 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47. - Los primeros primos I.
Elabore una función Python llamada primeros_primos(), que reciba un número n, y devuelva una lista con los números primos entre 2 (1 no es primo) y el número n. Por ejemplo,
si n = 10, el resultado es la lista [2,3,5,7]
si n = 30, el resultado es la lista [2,3,5,7,11,13,17,19,23,29]
si n = 25, el resultado es la lista [2,3,5,7,11,13,17,19,23] - Los primeros primos II.
Elabore una función Python llamada cuantos_primos(), que reciba un número n, y determine cuántos primos son menores o iguales que n. Por ejemplo,
si n = 10, el resultado es la lista 4
si n = 30, el resultado es la lista 10
si n = 25, el resultado es la lista 9 - N-ésimo primo.
Elabore una función Python que determine el primo enésimo, n. La función se llama enésimo_primo(). Por ejemplo,
si n = 9, la salida es 23
si n = 18, la salida es 61 - Número abundante.
Un número abundante es aquel en el que los divisores propios del número (todos los divisores excepto el propio número) sumen más que el doble del número.
Por ejemplo, para 24, sus divisores son 1, 2, 3, 4, 6, 8, 12, 24 cuya suma es 60. Como 60 es mayor que 2×24=48, el número 24 es abundante. Y su abundancia es 60 − 2 × 24 = 12.
("Número abundante", 2020)
Construya una función en pseudocódigo que reciba un número x, y determine si es abundante. - Números amigos.
Dos números amigos son dos números enteros positivos a y b tales que la suma de los divisores propios de uno es igual al otro número y viceversa. Por ejemplo, para 220 y 284, se tiene que la suma de los divisores propios de 220 es 1 + 2 + 4 + 5 + 10 + 11 + 20 + 22 + 44 + 55 + 110 = 284, y la suma de los divisores propios de 284 es 1 + 2 + 4 + 71 + 142 = 220. Si un número es amigo de sí mismo (es igual a la suma de sus divisores propios), recibe entonces el nombre de número perfecto.
("Números amigos", 2020) - Números semi-perfectos.
Un número semi-perfecto a aquel número natural n que es igual a la suma de algunos de sus divisores propios. Por ejemplo:
12 tiene los divisores 1, 2, 3, 4, 6, y 2 + 4 + 6 = 12. Por lo tanto, es semiperfecto.
Construya una función Python que determine si un número n dado es semiperfecto. - Números semi-perfectos I.
Un número semi-perfecto a aquel número natural n que es igual a la suma de algunos de sus divisores propios. Por ejemplo:
12 tiene los divisores 1, 2, 3, 4, 6, de los cuales 2 + 4 + 6 = 12. Por lo tanto, es semiperfecto.
Construya una función Python que determine si un número n dado es semiperfecto. - Números semi-perfectos II.
Un número semi-perfecto a aquel número natural n que es igual a la suma de algunos de sus divisores propios.
Por ejemplo: tiene los divisores 1, 2, 3, 4, 6, de los cuales 2 + 4 + 6 = 12. Por lo tanto, es semiperfecto.
Construya una función Python que determine los primeros n números naturales semiperfectos. - Números de la suerte.
Flavious Josephus (año 37 a 38 de la era cristiana) contaba la historia del asedio de Yodfat, donde él y sus 40 soldados estaban atrapados en una caverna con la salida bloqueada por los romanos. Para no ser capturados, eligieron suicidio. Esta es la historia como aparece en el libro Mathematical Curiosities de Posamanteir & Lehmann para plantear el problema de los números de la suerte, que se conoce como el‘problema de Josephus'.
Supongamos los primeros 20 números naturales:
1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20.
Se asume que se comienza salvando el número 1 y se comienza borrando los números contando cada dos
1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20.
lo que deja:
1,3,5,7,9,11,13,15,17,19
El siguiente número que no se toca es el 3, por lo que se cuenta de nuevo cada 3 números para eliminarlos
1,3,5,7,9,11,13,15,17,19
lo que deja:
1,3,7,9,13,15,19.
El siguiente número que no se toca es el 7, por lo que se cuenta de nuevo cada 7 números para eliminarlos
1,3,7,9,13,15,19.
lo que deja:
1,3,7,9,13,15.
Como ya terminamos con la lista de números, esos son los números suertudos.
Construya un programa en Python que determine cuáles son los primeros n números enteros suertudos. - Números suertudos entre los no suertudos.
Suponga el problema anterior sobre números suertudos, de modo siempre exista una lista de números eliminados. Use la lista de los números eliminados en la búsqueda de los primeros n números suertudos (ver problema anterior), para determinar dentro de los eliminados la nueva lista de números con una segunda oportunidad. Por ejemplo, para los números enteros del 1 al 20, la lista de eliminados es:
2,4,5,6,8,10,11,12,14,16,17,18,19,20
Los números con una segunda oportunidad se hallarían usando el algoritmo ya aplicado, por lo que, si comenzamos en el segundo número, que es el número 4, la siguiente secuencia sería:
2,4,5,6,8,10,11,12,14,16,17,18,19,20
dejando así
2,4,5,8,10,11,14,16,17,19,20
se deja el número 5, por lo que la siguiente eliminación es cada 5
2,4,5,8,10,11,14,16,17,19,20
y queda
2,4,5,8,11,14,16,17,20
Sigue el 8, y vemos que contando cada 8 tenemos
2,4,5,8,11,14,16,17,20
quedando
2,4,5,8,11,14,16,20
Sigue el 11, pero ya no habría un número decimo primero qué se pueda eliminar, por lo que los números de segunda oportudidad son los que se muestran en la lista.
Construya un programa Python que determine la lista de números de segunda oportunidad dado n. - Lista de representaciones numéricas.
Construya una función Python que emita una lista en pantalla con la representación binaria, octal, y hexadecimal entre dos números a y b dados como parámetros. La lista contendrá el número en decimal, y las equivalencias solicitadas. Apóyese en las funciones bin(), oct() y hex() de Python disponibles en la librería __builtins__. - Dígito hexadecimal a número entero.
Construya una función Python que, dado un hexadecimal representado como string, y dada una posición de dígito numérico posicional, determine el valor decimal del dígito. Por ejemplo,
para “BECA”y posición 1, 12*16=192 (C es 12 y la base es 16)
para “BECA”y posición 0, 10*1 = 10 (A es 10 y la base es 16) - Dígito en cualquier base a número entero.
Construya una función Python que, dado un número en cualquier base, máximo base 36, representado como string, y dada la base y una posición de dígito numérico posicional, determine el valor decimal del dígito. Se usan sólo los siguientes dígitos: “0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ”
Nota: no puede usar la función int() de Python.
Por ejemplo,
para “TIMBRE”, base 36, pos 0, 14*1=14 (E=14, base=36)
para “TIMBRE”, base 36, pos 1, 27*36=972 (R=27, base=36)
para “TIMBRE”, base 30, pos 0, 14*1=14 (E=14, base=30)
para “TIMBRE”, base 30, pos 1, 27*30=810 (R=27, base=30)
para “CASTOR”, base 36, pos 5, 12*36^5 = 725594112
para “CASTOR”, base 36, pos 4, 12*36^4 = 20155392 - Conversión decimal a binario.
Construya una función Python dectobin() que devuelva la representación binaria de un número a través de divisiones sucesivas. La representación binaria es una string. Por ejemplo,
para el número 1177, la función bin(1177) es '10010011001'.
Veamos cómo:
1177 ÷ 2 = 558 residuo 1
588 ÷ 2 = 294 residuo 0
294 ÷ 2 = 147 residuo 0
147 ÷ 2 = 73 residuo 1
73 ÷ 2 = 36 residuo 1
36 ÷ 2 = 18 residuo 0
18 ÷ 2 = 9 residuo 0
9 ÷ 2 = 4 residuo 1
4 ÷ 2 = 2 residuo 0
2 ÷ 2 = 1 residuo 0
1 ÷ 2 = 0 residuo 1
Si se toman todos los residuos, se obtiene el número binario de atrás hacia adelante: 10010011001.
Construya una función Python que despliegue en consola un listado en pantalla con la representación binaria de los números entre 1 y 15. El listado contendrá dos campos: el numero decimal, y el número binario. Use la función dectobin() construida en el literal anterior. - Conversión decimal a hexadecimal.
Construya una función Python dectohex() que devuelva la representación hexadecimal de un número a través de divisiones sucesivas. La representación hexadecimal es una string. Por ejemplo,
para el número 991, la función hex(991) es '3DF'
Veamos cómo:
991 ÷ 16 = 61 residuo 15, pero 15 en hex es F
61 ÷ 16 = 3 residuo 13, pero 13 en hex es D
3 ÷ 16 = 0 residuo 3.
Si se toman todos los residuos, se obtiene el número hexadecimal de atrás hacia adelante: 3DF. - Conversión decimal a base 36.
Si se considera que en hexadecimal(base 16) vamos hasta 15 (A es 10, hasta F que es 15), se pueden seguir extendiendo las letras hasta la Z=35, para una base 36. Construya una función Python to_int() que le permita convertir un número entero x a cualquier base b, y el resultado es la representación en la base solicitada. Se presentan a manera de ejemplos de llamada y sus resultados:
to_int (46567, 20) = ‘5G87’
to_int (1043811637513740, 36) = ‘AA00G2K270’
to_int (47786661583, 35) = ‘PYTHON3’
to_int (22464, 30) = ‘OSO’
to_int (169785,25) = ‘ALGA’
to_int (48830, 16) = ‘BEBE’
to_int (555, 6) = ‘215’
to_int (222,3) = ‘26’
Para probar su función, puede usar la clase int de Python, así: suponga que desea ver si OSO en base 30 es efectivamente es el número 22464.
Vaya a una consola de Python, y escriba int(“OSO”, base = 30). El resultado deberá ser su número 22464. - Convertir de binario a decimal.
Elabore una función en Python llamada bin_to_dec(), que convierta un número binario representado como string a número decimal, sin usar la función int() de Python. Por ejemplo:
‘1000’= 23 = 8
‘1001’= 23 + 20 = 8 + 1 = 9
‘1011001’= 26 + 24 + 23 + 20 = 64 + 16 + 8 + 1 = 89 - Convertir de hexadecimal a decimal.
Elabore una función en Python llamada hex_to_dec(), que convierta un número hexadecimal representado como string a número decimal, sin usar la función int(), o hex() de Python. Por ejemplo:
‘AFB’es 2811
‘AFB007’es 11513863 - Convertir de hexadecimal a binario.
Elabore una función en Python llamada hex_to_bin(), que convierta un número hexadecimal representado como string a número decimal, sin usar la función int(), o hex() de Python. Por ejemplo:
‘AFB’es 0b101011111011
‘AFB007’es 0b101011111011000000000111 - Número en cualquier base a número entero.
Construya una función Python que, dado un número en cualquier base, máximo base 36, representado como string, determine el valor decimal del número. Se usan sólo los siguientes dígitos: “0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ”
Nota: no puede usar la función int() de Python.
Por ejemplo,
para “COFFE”, base 36, devuelve 21295130
para “PUNK”, base 31, devuelve 774338
para “TIMBRE”, base 30, devuelve 719884724
para “LOVE”, base 32 devuelve 713710 - Número entero a cualquier base hasta base 36.
Construya una función Python que, dado un número entero, lo represente en una base específica dada, máximo base 36, Se usan sólo los siguientes dígitos: “0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ” - Número entero a cualquier base hasta base 62.
Construya una función Python que, dado un número entero, lo represente en una base 62 que soporte letras mayúsculas y minúsculas. Se usan sólo los siguientes dígitos: “0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz” - Número entero a número base ASCII imprimible.
Construya una función Python que, dado un número entero, lo represente en una base que extraiga los dígitos desde la tabla ascii, y sólo de aquellos caracteres que son imprimibles, esto es, visibles. No podrá incluir caracteres de control que tengan sentido especial para el sistema. - Cadenas a binario.
Construya una función en Python que, dada una string con caracteres ASCII, la represente en binario. Dado que cada caracter de la cadena tiene un código, obtenga el código y represéntelo como número binario. Concatene todas las representaciones binarias para obtener un único número binario. Tenga en cuenta que cada número binario debe estar compuesto de 8 dígitos binarios para obtener un byte exacto. Por ejemplo, para
"Melissa", los códigos son [77, 101, 108, 105, 115, 115, 97] y el binario correspondiente juntando los binarios de las letras, es 01001101011001010110110001101001011100110111001101100001 - Cadenas a hexadecimal.
Construya una función en Python que, dada una string con caracteres ASCII, la represente en hexadecimal. Dado que cada caracter de la cadena tiene un código, obtenga el código y represéntelo como número hexadecimal. Concatene todas las representaciones hexadecimales para obtener un único número hexadecimal. Tenga en cuenta que cada número hexadecimal debe estar compuesto de 2 dígitos binarios para obtener un byte exacto. Por ejemplo, para
"Melissa", los códigos son [77, 101, 108, 105, 115, 115, 97] y el hexadecimal correspondiente juntando los hexadecimales de las letras, es 4d656c69737361 - Pase un nombre a nombre genómico. [BIO]
Construya una función en Python que, dada una string con caracteres ASCII, la represente como una cadena de ADN. Debido a que su nombre está compuesto de caracteres ascii, y dado que un caracter ascii tiene código, podríamos generar una lista de códigos, que unificados como una cadena, sería una cadena de dígitos. Si a los nucleótidos asignamos un código, por ejemplo 0 a la 'A', 1 a la 'C', 2 a la 'G' y 3 a la 'T', podríamos convertir su nombre en cadena genética. Eso lo haríamos dividiendo por 4 aquellos dígitos mayores a 3, y usando el residuo de la división (0,1,2,3) como la letra. Por ejemplo, si el nombre es 'Manuela' los ascii codes son [77, 97, 110, 117, 101, 108, 97], que unificados en cadena quedan "779711011710110897", y esa es la base para los nucleótidos. Los dígitos 0,1,2 y 3 paran directo como A, C, G y T. Para los demás usamos residuos de dividir por 4, por lo que la cadena queda "TTCTCCACCTCACCAACT". - Pase un nombre a nombre protéico. [BIO]
Construya una función en Python que, dada una string con caracteres ASCII, la represente como una cadena de proteínas. Use los códigos ascii unificados como una string, y luego la cadena de ADN pásela a aminoácidos con codones. Use una tabla estándar de codones para hacer el paso a aminoácidos. Si no logra completar el último codón, reempácelo por un codón de parada. Por ejemplo, si el nombre es 'Manuela' los ascii codes son [77, 97, 110, 117, 101, 108, 97], que unificados en cadena quedan "779711011710110897", y esa es la base para los nucleótidos. Los dígitos 0,1,2 y 3 paran directo como A, C, G y U (a cambio de T). Para los demás usamos residuos de dividir por 4, por lo que la cadena queda "UUC UCC ACC UCA CCA ACU". Si se pasa a aminoácidos, la cadena queda "FSTSPT". - Intercambio de extremos.
Elabore una función Python que reciba una string, y cree una nueva cadena donde el primer y último caracter están intercambiados. Por ejemplo, si la cadena es “Intercambiar”, la función devuelve “rntercambiaI". - Unir extremos.
UsePython para unir en una cadena, la primera y última palabra de una string, unidas por el caracter coma(",").
para “1 2 3 4 5 6 7”devuelve "1,7".
para “Rápido ruedan los carros cargados”devuelve “”Rápido,cargados”. - Suma de dígitos.
Construya una función Python que dada una string que representa un número, determine la suma de sus dígitos. - Extraer el número.
Durante un texto de una conversación, la persona con la que más quisieras compartir, y con la que nunca has compartido, te dejó el número de celular. Es el único número en el texto. Construya una función Python que, sin usar la función split() de Python, devuelva el número del celular. Por ejemplo,
para “…y si quieres, me puedes llamar al 3214567890 para que hablemos.”devuelve “3214567890” - Extraer los números.
Use la función split() de Python para sumar todo numero de una cadena que no pertenezca a una palabra. Por ejemplo,
para “este es el 1ro”devuelve 0.
para “4quí solo hay 1 y yo nec3sito 2”devuelve 3. - Función capitalize.
Escriba una función Python que cambie el primer caracter de una cadena a mayúscula, sin usar la función capitalize() de Python. - Función count.
Escriba una función Python que, dadas dos cadenas, cuente cuántas veces está la segunda en la primera, sin usar la función count() de Python. - Función upper.
Escriba una función Python que, dado un texto, convierta todas sus letras a mayúsculas, sin usar la función upper() de Python. - Función lower.
Escriba una función Python que, dado un texto, convierta todas sus letras a mayúsculas, sin usar la función lower() de Python. - Función isupper.
Escriba una función Python que, dado un texto, determine si todas las letras de la cadena son mayúsculas, sin usar la función isupper() de una cadena Python. - Función islower.
Escriba una función Python que, dado un texto, determine si todas las letras de la cadena son minúsculas, sin usar la función lower() de una cadena Python. - Función isinteger.
Escriba una función Python que, dado un texto, determine si todos los caracteres son dígitos, sin usar la función isdigit() de una cadena Python. - Función isfloat.
Escriba una función Python que, dado un texto, determine si todos los caracteres son dígitos, y hay exactamente un caracter punto (‘.’). A la derecha del punto deberá haber al menos un dígito. - Función isalphabetic.
Escriba una función Python que, dado un texto, determine si no hay ningún dígito en el texto. - Función ishexadecimal.
Escriba una función Python que, dado un texto, determine si todos los caracteres de la cadena pertenecen al conjunto de caracters que representan un número hexadecimal. - Función isbinary.
Escriba una función Python que, dado un texto, determine si todos los caracteres de la cadena solo son ceros y unos. - Fución startswith.
Escriba una función Python que reciba dos strings, y determine si la primera comienza con la segunda. No puede usar la función Python startswith() - Fución endsswith.
Escriba una función Python que reciba dos strings, y determine si la primera termina con la segunda. No puede usar la función Python endswith(). - Función len.
Escriba una función Python que, dada una cadena, determine el tamaño de esta. No puede usar la función len() de Python. - Función istitle.
Escriba una función Python istitle() que determine, dentro de una cadena, si las palabras comienzan con mayúscula, mientras que las demás letras de la palabra son minúsculas. No puede usar la función istitle() de Python. Por ejemplo,
istitle(“El algoritmo”) devuelve False
istitle(“El Algoritmo”) devuelve True
Si dentro de una palabra hay caracteres especiales o números, no cuenta como tiele. Por ejemplo,
istitle(“El Algoritm0”) devuelve False - Función lower.
Escriba una función Python que elimine las mayúsculas de una string convirtiéndolas a minúsculas. - Palabra delimitada.
Dada una string, un caracter de apertura delimitador, y un caracter de cierre delimitador, extraer la substring delimitada. Se garantiza una sola palabra delimitada. Por ejemplo,
para “el valor es $100.09; iva al final”y ("$",”;”), devuelve “100.09”
para “el rango es [12,29]”y ("[","]"), devuelve “12,29”
para “me llamo 'carlos'”y ("'","'"), devuelve "carlos" - Palabras delimitadas.
Dada una string, un caracter de apertura delimitador, y un caracter de cierre delimitador, extraer las substring delimitada en una lista. Por ejemplo,
para “vienen 'elisa' y 'carlos' a cenar”y ("'","'"), devuelve ["elisa","carlos"] - Función strip.
Construya una función Python que elimine los espacios en blanco que hayan a la izquierda y a la derecha de una cadena, sin usar la función strip() de Python.
Por ejemplo,
strip (" sin espacios ") da "sin espacios" . - Función lstrip.
Construya una función Python que elimine los espacios en blanco que hayan a la izquierda de una cadena sin usar la función lstrip( ) de Python. Por ejemplo,
lstrip (" izquierda limpia ") da "izquierda limpia " . - Función rstrip.
Construya una función Python que elimine los espacios en blanco que hayan a la derecha de una cadena, sin usar la función rstrip( ) e Python. Por ejemplo,
rtrip (" derecha limpia ") da " derecha limpia" . - Función ljust.
Contruya un función Python que ajuste una cadena hacia la izquierda tantos lugares como se indique. Si se indican menos lugares que el tamaño de la string, no surte efecto. Se podrá especificar con qué caracter se ajusta (sólo uno!), pero si no se especifica, se asume el caracter espacio. No se podrá usar el método ljust() de un objeto string.
Por ejemplo:
ljust(“123456789”,20) da “123456789 ”
ljust(“123456789”,2) da “123456789”
ljust(“123456789”,25, '0') da “1234567890000000000000000”
ljust(“123456789 ”,25, '0') da “123456789 00000000000” - Función rjust.
Contruya un función Python que ajuste una cadena hacia la derecha tantos lugares como se indique. Si se indican menos lugares que el tamaño de la string, no surte efecto. Se podrá especificar con qué caracter se ajusta (sólo uno!), pero si no se especifica, se asume el caracter espacio. No se podrá usar el método rjust() de un objeto string.
Por ejemplo:
rjust(“123456789”,20) da “ 123456789”
rjust(“123456789”,2) da “123456789”
rjust(“123456789”,25, '0') da “0000000000000000123456789”
ljust(“ 123456789”,25, '0') da “0000000000 123456789” - Función zfill, Contruya un función Python que ajuste una cadena hacia la derecha tantos lugares como se indique, rellenando de ceros cuando sea necesario. En el caso que hayan espacios antes del primer caracter que no es espacio, los caracteres espacio contaran como parte del relleno. Si se indican menos lugares que el tamaño de la string, no surte efecto. No se podrá usar el método zfill() de un objeto string.
Por ejemplo:
zfill(“123456789”,20) da “00000000000123456789”
zfill(“123456789”,2) da “123456789”
zfill(“123456789”,25) da “0000000000000000123456789”
zfill(“ 123456789”,25) da “0000000000 123456789” - Función swapcase.
Construya una función python que, dada una cadena, cambie las minúsculas a mayúsculas, y las mayúsculas a minúsculas. No puede usar la función swapcase() de python. - Función center.
Construya una función Python que centre una string dado un tamaño, rellenando con blancos a ambos lados de la string. Si se debe adicionar un caracter blanco adicional en el caso que los caracteres a la izquierda no sean iguales a los de la derecha, se hace a la derecha. Si el tamaño es menor a la string, no hay efecto. Si No puede usar la función center() de python. Por ejemplo,
center(“12345”, 5) devuelve “12345”
center(“12345”, 15) devuelve “ 12345 ”
center(“12345”, 16) devuelve “ 12345 ” - Función replace.
Construya una función Python que reemplace una substring dada por otra también dada, en una string especificada.
Por ejemplo,
replace("12345",'1','8') devuelve '82345'
replace("12345”,'88') devuelve'88345'
replace("una cosa es una cosa y otra cosa es otra cosa", "cosa","vida”) devuelve "una vida es una vida y otra vida es otra vida" - Función Split.
- Construya una función Python que, dado un texto, devuelva una lista Python, donde cada posición es una palabra. No puede usar el método split() del objeto string en Python.
- Función SplitByChar.
Construya una función Python que, dado un texto y un caracter, localice el caracter dado, y parta la string en ese punto. Todas las substring posibles deben llevarse a una lista Python, y el caracter que se usó para partir es eliminado de las palabras. La función devuelve la lista. No puede usar el método split() del objeto string en Python. - Función SplitBySubstring.
Construya una función Python que, dado un texto, localice el caracter dado, y parta la string en ese punto. Todas las substring posibles deben llevarse a una lista Python. La función devuelve la lista. No puede usar el método split() del objeto string en Python. - Función splitlines.
Construya una función Python que determine la localización del caracter de salto de línea (ASCII 10), y devuelva una lista Python donde cada posición es una línea. No use la función Split() de Python. - Invertir string
Construya una función Python que reciba una string, y genere otra que es la string invertida. Por ejemplo
si entra “amar”, sale“rama”
si entra “sopa”, sale“apos”
si entra “ACGT”, sale“TGCA" - Función mini_eval sin prioridad.
Construya una función Python que reciba una string que representa una operación aritmética simple, donde las operaciones son palabras en español. Por ejemplo, dada la string:
“19 mas 8 menos 7 por 4 dividido 2”, la función devuelve 40
En esta función mini_eval no hay paréntesis, y la evaluación corre de izquierda a derecha, asumiendo que todas las operaciones tienen la misma prioridad.
La evaluación corre 19+8=27–7=20*4=80/2=40
No use en ningún momento la función eval de Python. - Función mini_eval con prioridad.
Construya una función Python que reciba una string que representa una operación aritmética simple, donde las operaciones son palabras en español, donde multiplicar y dividir tienen más prioridad que sumar y restar. Por ejemplo, dada la string:
“50 mas 8 menos 7 por 4 dividido 2”, la función devuelve 44
La evaluación corre 7*4=28/2=14
luego:
50+8=58-14 = 44
No use en ningún momento la función eval de Python. - Función eval con prioridad, de un nivel de paréntesis.
Construya una función Python que reciba una string que representa una operación aritmética que puede contener expresiones entre paréntesis de un solo nivel para priorizar partes de la operación. Los operadores aritméticos de división y multiplicación tienen mayor prioridad que los operadores suma y resta. Por ejemplo, dada la string:
“(4+5)*2-(2+8)/2”, la función devuelve 8
La evaluación corre (9)*2-(10)/2= 8 - Función eval con prioridad, paréntesis multinivel.
Construya una función Python que reciba una string que representa una operación aritmética que puede contener expresiones entre paréntesis. Use las mismas prioridades de Python para los operadores. Por ejemplo, dada la string:
“((4+(5+3)/2+1)*2-2+8)/2”, la función devuelve 12
No use en ningún momento la función eval de Python. - Complementaria ADN. [BIO]
Construya una función Python que devuelva la cadena complementaria de una secuencia de ADN. Una cadena simple de ADN se complementa con otra cadena, sobre la base que A y T se complementan mutuamente, al igual que lo hacen C y G. Por ejemplo,
la cadena “ACGT”se complementa con “TGCA”
la cadena “ACGTTATAGCCATT”se complementa con “TGCAATATCGGTAA” - Cadenas Complementarias ADN. [BIO]
Construya una función Python que reciba una lista de cadenas ADN, y devuelva una nueva lista con cadenas complementarias. Una cadena simple de ADN se complementa con otra cadena reemplazando el caracter 'A' por el caracter‘T' y viceversa, al igual que reemplazando el caracter 'G' por el caracter‘C' y viceversa. Por ejemplo,
Si la entrada es ["ACGT","TTATAGCCA"] la salida es ["TGCA","AATATCGGT"] - Contar un tipo de nucleotido. [BIO]
Construya una función Python que cuente cuántos nucleótidos del mismo tipo que el primero de la cadena, hay en toda la cadena. Por ejemplo
para la cadena “ACGTTATAGCCATT”el primer nucleótido es A. La función devuelve 4.
para la cadena “TCCGTTATTGCACGTTATAGCCATT”el primer nucleótido es T. La función devuelve 10. - Contar caracter concreto.
Dada una string y un caracter, construya una función Python que calcule cuántas veces está el caracter en la string. - Estadística letras I – Lista de tuplas.
Construya una función Python que, dada una string, genere un arreglo de tuplas con la estadística de las letras de los caracteres en la string. El arreglo de salida contendrá solo aquellos caracteres que se encuentran disponibles en la cadena. Cada elemento del arreglo de salida contendrá una tupla con el caracter y el conteo. Por ejemplo,
Si la cadena es “tall”, devuelve [(‘t’,1) , (‘a’,1) , (‘l’,2)] - Estadística letras II - Diccionario.
Construya una función Python que, dada una string, genere un diccinario con la estadística de las letras de los caracteres en la string. El diccionario de salida contendrá como clave la palabra, y como valor las veces que se repite la palabra en el texto. Por ejemplo,
Si la cadena es “tall”, devuelve {‘t’: 1 , ‘a’: 1 , ‘l’: 2 } - Substring existe.
Construya una función Python que reciba dos strings, y diga si en la primera string, existe la segunda. Por ejemplo
si las cadenas son "una" ,“construya una función” devuelve .t.
si las cadenas son "dos" , “construya una función” devuelve .f. - Contar diferencias I.
Construya una función Python que reciba dos strings que determine cuántos caracteres son diferentes en ambas. Si hay una string más larga que otra, la diferencia en sus longitudes cuenta. Por ejemplo,
si las dos cadenas son “pseudocode”y “pseudo”, la diferencia es 4.
si las dos cadenas son “canon”y “nikon”, la diferencia es 3.
si las dos cadenas son “haskel”y “python”, la diferencia es 6. - Contar diferencias I.
Construya una función Python que reciba dos strings que determine cuántos caracteres son diferentes en ambas. Si hay una string más larga que otra, la diferencia en sus longitudes no cuenta. Por ejemplo,
si las cadenas son “pseudocode”y “pseudo”, la diferencia es 0.
si las cadenas son “canon”y “nikon”, la diferencia es 3.
si las cadenas son “haskel”y “python”, la diferencia es 6. - Enzimas de restricción. [BIO]
Construya una función Python que reciba una string que contiene una secuencia de ADN, y un arreglo de strings que contiene secuencias de enzimas de restricción. La función deberá indicar cuáles secuencias de enzimas de restricción se encuentran en la secuencia de ADN, y cuántas veces está presente. Tenga en cuenta que si una enzima no está presente, no deberá aparecer en la lista de salida. La función devuelve un arreglo de tuplas con la información. Por ejemplo, si la secuencia ADN es “...CCTCTTTAGGCAGGCAGAGAATTCTTATCGAATACGGCGTAAGTCAGGT...”,
y el arreglo de enzimas contiene
[“GAATTC”, “GGATCC” , “AGTC”],
la función devuelve el arreglo [("GAATTC",1),("AGTC",1)]. - Eliminar blancos repetidos I.
Dada una string que representa un texto, construya una función Python que devuelva una string donde los espacios en blanco repetidos hayan sido eliminados. Por ejemplo,
si el texto es “next generation digital information.”
la salida es “next generation digital information.” - Eliminar blancos repetidos II.
Dada una string que representa un texto, construya una función Python que devuelva una string donde los espacios en blanco repetidos hayan sido eliminados.
Restricción: No puede usar el método split( ) de strings disponible en Python. Por ejemplo,
si el texto es “next generation digital information.”
la salida es “next generation digital information.” - Veces palabra I.
Construya una función Python que reciba dos strings, una que representa un texto, y otra que representa una palabra, y busque cuántas veces está la palabra en el texto. - Veces palabra II.
Construya una función Python que reciba dos strings, una que representa un texto, y otra que representa una palabra, y busque cuántas veces está la palabra en el texto.
Restricción: No puede usar los métodos de búsqueda de Python. Use comparaciones caracter a caracter. - Contar palabras I.
Construya una función Python que reciba una string que representa un texto, y cuente cuántas palabras hay. Use la función Split( ) de cadenas como la primera parte de la solución.
"el zorro quería; pero no pudo. ;”, devuelve 6 - Contar palabras II.
Construya una función Python que reciba una string que representa un texto, y cuente cuántas palabras hay.
Restricción: No puede usar el método Split de strings disponible en python.
"el zorro quería; pero no pudo. ;”, devuelve 6
"el zorro quería comer uvas y pudo comer uvas”, devuelve 9 - Separar palabras.
Construya una función que reciba una string que representa un texto, y separe todas las palabras en un nuevo arreglo sin palabras repetidas. Por ejemplo
"el zorro quería comer uvas y pudo comer uvas”, devuelve
["el", "zorro", "quería", "comer", "uvas", "y", "pudo"]. - Separar palabras repetidas.
Construya una función que reciba una string que representa un texto, y separe todas las palabras que estén repetidas en el texto. Se crear un nuevo arreglo que contiene solo las palabras que ya están repetidas. El nuevo arreglo no repetirá las palabras repetidas. Por ejemplo:
"el zorro quería comer uvas y pudo comer uvas”, devuelve ["uvas”,"comer"]
"el zorro quería comer uvas pero no pudo”, devuelve []. - Palabras que presentan un caracter dado contiguo n veces.
Construya una función Python que reciba una string y un caracter, y devuelva un arreglo con las palabras que contienen más veces el caracter dado. Por ejemplo,
para "good book keeper", caracter 'k', devuelve
["book" "keeper"]
para "good book keeper", caracter 'o', devuelve
["good", "book"]
para "you are a fool", caracter 'o', devuelve ["fool"] - Palabras con mayor número de caracteres repetidos contiguos.
Construya una función en Python que reciba una string, y devuelva un arreglo con las palabras con el caracter que más se repite. Si hay dos caracteres que son los que más se repiten, se devuelven aquellas con el caracter lexicográficamente menor. Por ejemplo,
para "good book keeper", devuelve ["keeper"]
para "you are a fool", devuelve ["fool"] - Palabra más larga, lexicográficamente menor.
Construya una función Python que reciba un texto, y devuelva la palabra más larga, lexicográficamente menor. En este algoritmo, se toman las palabras de mayor longitud y se comparan. La menor se devuelve. Se debe tener en cuenta que las palabas más largas que se comparen, son de la misma longitud. - Párrafo alineado.
Los editores de texto plano contienen funcionalidades de alineamiento, de tal modo que el texto se despliegue dentro de un ancho específico de salida. Construya un programa Python que, dada una string, imprima el texto con base en el ancho de pantalla especificado, de tal modo que las palabras no se rompan entre líneas.
Por ejemplo, si el texto es "no puedes depender de tus ojos si tu imaginación está fuera de foco.", y el tamaño de línea es 30, la salida es
"no puedes depender de tus"
"ojos si tu imaginación está"
"fuera de foco." - Justificación de párrafo a tamaño de línea.
Los editores de texto plano contienen funcionalidades de alineamiento, de tal modo que el texto de los párrafos se despliegue dentro de un ancho específico de salida sin que las palabras se rompan, y, además, se ajusten para cubrir el tamaño de línea. Los párrafos de un texto se definen como aquellos terminados en un caracter de salto de línea. La última línea no se ve sometida a este ajuste.
Por ejemplo, si el texto es
"no puedes depender de tus ojos si tu imaginación está fuera de foco.
El que va subiendo lleva la vía, y el esfuerzo mata la excusa.", y el tamaño de línea es 20, la salida es
"no puedes depender"
"de tus ojos si tu"
"imaginación está"
"fuera de foco."
"El que va subiendo"
"lleva la vía, y el"
"esfuerzo mata la"
"excusa."
Construya un programa en Python que tome una cadena y un tamaño de línea, y la justifique, sin hacer uso de librerías de formato de textos. - Argumentos de línea de Comandos I.
Las aplicaciones de línea de comandos Python pueden recibir parámetros desde la misma línea de comandos con la que se llama un programa. Luego del nombre del programa, todos los valores ingresados entre espacios, se consideran argumentos independientes. Muchas estrategias son comunes para escribir estos argumentos en la línea de comandos, de tal modo que sean identificados dentro de la aplicación.
Para este ejercicio, suponga que los argumentos son nombres de variables seguidos del signo igual y un valor. Construya un programa Python que, al ser invocado desde línea de comandos, prepare un diccionario donde las claves son los nombres de las variables, y los valores se asocian a las claves respetivas.
Por ejemplo:
$ >python3 programa.py a=100 b=200 c=300
Genera internamente el diccionario
{'a':'100', 'b':'200', 'c':'300'}
La salida será el diccionario impreso en pantalla. - Argumentos de línea de Comandos II.
Similar a lo presentado en el problema anterior, suponga que un argumento de línea de comando puede contener varios valores.
Por ejemplo:
$ >python3 programa.py a=100,200,300 b=400,500 c=600
Construya un programa Python que genera un diccionario, donde los valores de cada una de las entradas se almacenan en una lista. Para el caso anterior, el diccionario que se obtiene es
{'a':['100', '200', '300'], 'b':['400', '500'], 'c':['600']}
La salida será el diccionario impreso en pantalla. - Mayor dígito.
Dado un texto cualquiera, determine el dígito mayor presente dentro del texto. Si no hay dígitos, la función devuelve el valor None. - Números dentro de texto.
Dado una string, emita una lista con aquellas palabras del texto que son números. - ¿es número Kaprekar dual?
Los cuadrados de algunos números enteros pueden ser fragmentados en alguna parte de sus dígitos, y los números resultantes sumados para obtener de nuevo el número que fue elevado al cuadrado. Por ejemplo,
1 -> 1^2 -> 1
9 -> 9^2 = 81 -> 8 + 1 = 9
45 -> 45^2 = 2025 -> 20 + 25 = 45
999 -> 999^2 = 998001 -> 998 + 001 = 999
4879 -> 4879^2 -> 23804641 -> 238 + 04641 = 4879
(Posamenter & Lehmann, 2014, pag 50)
Construya una función Python que determine si un número x es un número Kaprekar. - Primeros N números duales de Kaprekar.
Los cuadrados de algunos números enteros pueden ser fragmentados en alguna parte de sus dígitos, y los números resultantes sumados para obtener de nuevo el número que fue elevado al cuadrado. Por ejemplo,
1 -> 1^2 -> 1
9 -> 9^2 = 81 -> 8 + 1 = 9
45 -> 45^2 = 2025 -> 20 + 25 = 45
999 -> 999^2 = 998001 -> 998 + 001 = 999
4879 -> 4879^2 -> 23804641 -> 238 + 04641 = 4879
(Posamenter & Lehmann, 2014, pag 50)
Construya un programa Python que determine los N primeros números Kaprekar, emitiendo la lista de sus términos.
por ejemplo, la lista de arriba deberá aparecer como:
x x^2 serie
1 1 1
9 81 8 + 1
45 2025 20 + 25 = 45
999 998001 998 + 001 = 999
4879 23804641 238 + 04641 = 4879
los cuadrados hallados pueden ser fragmentados en 2 números en cualquier posición. - La curiosa constante de Kaprepar.
Todo número de cuatro dígitos donde no hayan más de 2 dígitos repetidos, puede ser llevado al curioso número 6174 conocido como constante de Kaprekar, usando el siguiente algoritmo:
tome el número y ordene sus dígitos de tal forma que obtenga el mayor número posible, y haga lo mismo para obtener el menor. Sume los dos números obtenidos. Si no ha obtenido 6174, repita la operación con el resultado.
(Posamenter & Lehmann, 2014, pag 50)
Construya un programa Python que determine el número de pasos requeridos para llegar a la constante de Kaprekar a partir de un número de 4 cifras dado. - Caminata aleatoria.
Una caminata en dos dimensiones simula el comportamiento de una partícula que se mueve dentro de una retícula de 2n x 2n. A cada paso, la partícula se mueve al arriba, abajo, a izquierda o derecha, con una probabilidad de ¼, independiente del movimiento previo. Escriba una función en python que reciba el tamaño de la retícula cuadrada 2n, y estime qué tan larga en número de pasos es la caminata aleatoria antes de tocar alguno de los bordes, si siempre la partícula comienza en el centro de la retícula.
(Sedgewick & Wayne, 2017)
NOTA: Para generar un número aleatorio en Python, use la función random.random() o random.randrange(). - El problema de Pepys.
En 1963, Samuel Pepys le preguntó a Isaac Newton, qué pasaría más fácil: obtener 1 al menos una vez al tirar un dado seis veces, o obtener 1 al menos dos veces al tirar un dado 12 veces. Escriba una función que sea capaz de dar respuesta a esta pregunta.
(Sedgewick & Wayne, 2017) - Números y sus dígitos potenciados a la potencia 4.
Posamenter y Lehmann, en su libro Mathematical Curiosities, en la página 53, mencionan un número con una propiedad interesante, y es el 8208. Nos cuentan que 8208 = 84 + 24+ 04 + 84. Esto es, la suma de sus dígitos elevados a la cuarta potencia es igual al número.
Es una curiosidad que deja la duda: ¿hay otros?
Use su poder computacional para comprobar si hay otros números de más de un dígito con la misma propiedad, y cuáles si los hay. Indague sólo para el primer millón de números enteros. - Números y sus dígitos potenciados a la potencia n.
Según el problema anterior (Números y sus dígitos potenciados a la potencia 4), entra la duda de si podría haber otros números a los que le podamos encontrar la misma propiedad, pero con potencias distintas entre 2 y 9.
Use su poder computacional para comprobar si hay otros números con la misma propiedad. ¿cuáles si los hay, y con qué potencias? - Potencias de dos con dígitos excluidos.
Construya una función Python que, dado un rango de potencias de 2 de números positivos, 2n,2n+1,…,2m, determine si alguno de esos números no contiene un dígito w. El rango [n,m] y el dígito w, son dados como parámetro. - Potencias de dos con dígitos excluidos II.
Construya una función Python que, dado un rango de potencias de 2 de números positivos, 2n,2n+1,…,2m, determine si alguno de esos números no contiene un dígito en el rango [x,y]. El rango [n,m] y el rango [x,y], son dados como parámetro. La función devuelve un diccionario Python, que contiene cuántas veces no se usó un dígito específico en el rango de las potencias. - Exclusión de dígitos en potencias.
Construya una función Python que, dado un rango de bases [a,b], un rango de exponentes [c,d] y un rango de dígitos [e,f], determine para todas las posibles combinaciones, el dígito menormente representado y el mayormente representado. La función Python deberá devolver una tupla con los dos totales. - Chaos.
Escriba una función Python para estudiar el siguiente modelo sencillo popular de crecimiento poblacional, que puede ser aplicado para estudiar peces en una alberca, bacterias en un tubo de ensayo, o cualquier situación similar. Supongamos que la población va de 0 (extinta) a 1 (la máxima población sostenible). Si la población al tiempo t es x, entonces la población en el tiempo t + 1 es rx(1-x), donde r es un valor conocido como fecundidad, y que controla la velocidad de crecimiento.
La función Python comenzará con una población x que se pasa como parámetro y que es pequeña (digamos x = 0.01). Estudie el resultado del modelo iterando para varios valores de r. Para qué valores de r la población se estabiliza para en x = 1 - 1/r? ¿Puede decir algo sobre las poblaciones cuando r es 3?5? 3.8? 5?
(Sedgewick & Wayne, 2017) - Mayor Común Divisor.
El mayor común divisor de dos números n, m, es el mayor entero x que divide de forma exacta a n y m. Por ejemplo, si n = 78 y m = 21, el número más grande que los divide a los dos es x = 3. (Zwillinger, 2018, p.35).
Construya una función Python mcd(), que reciba m y n, y devuelva el mayor común divisor. - Mínimo Común Múltiplo.
El mínimo común múltiplo de dos enteros a y b, es el menor entero r que es divisible por a y por b. Por ejemplo, el mínimo común múltiplo de 10 y 4 es 20. (Zwillinger, 2018, p.35). Note que el entero más próximo a 10 y 4 que ambos dividen exactamente es 20. Construya una función Python llamada mcm(), que reciba a y b, y calcule r. - Valoración empírica generador random I.
Construya una función Python que genere números naturales aleatorios entre n y m, también naturales, dados como parámetros. Use la función random.randomrange() de Python para generar los números. Cuente cuántas veces está cada número generado. Determine el promedio de los totales. - Valoración empírica generador random II.
Construya una función Python que reciba una lista con tuplas, donde cada tupla es un rango n hasta m de valores, entre los cuales hay que generar números aleatorios. Cada una de las tuplas representa un experimento. Por cada una de las tuplas llame la función que desarrolló en el ejemplo anterior y guarde el resultado en una nueva lista. La función devolverá la lista de promedios. - Números abundantes en rango numérico.
Un número abundante es aquel en el que los divisores propios del número (todos los divisores excepto el propio número) sumen más que el doble del número.
Por ejemplo, para 24, sus divisores son 1, 2, 3, 4, 6, 8, 12, 24 cuya suma es 60. Como 60 es mayor que 2×24=48, el número 24 es abundante. Y su abundancia es 60 − 2 × 24 = 12.
("Número abundante", 2020)
Construya una función Python que reciba dos números a y b, y devuelva una lista con los números abundantes en el rango [a,b]. - ¿Es un número feliz?
Un número feliz es aquel en donde se puede llega a 1 a partir de elevar sus dígitos al cuadrado, sumarlos, y proceder recursivamente con los números resultantes, hasta que uno de esos números sea 1.
(Posamentier & Lehmann, 2014, pag.109)
Cómo, entonces saber si no llegará a 1? Queda como parte del ejercicio averiguarlo; si no es posible llegar a 1, es un número no feliz. Construya un programa Python que le permita determinar si un número es o no es feliz. Por ejemplo,
para n = 7, tenemos:
72=49; 42+92=97; 92+72=130; 12+32=10; 12+02 = 1 - Números felices en rango.
Dado el concepto de número feliz (ver problema anterior), construya un programa en Python que determine los números felices entre 1 y un número cualquiera dado n. - Números felices consecutivos.
Dado el concepto de número feliz de los problemas anteriores, construya un programa en Python que determine parejas de números felices consecutivos entre 1 y un número cualquiera dado n. Por ejemplo, se sabe que (31,32) es una pareja feliz. - Números primos felices.
Dado el concepto de número feliz de los problemas anteriores, construya un programa en Python que determine los números felices primos entre 1 y un número cualquiera dado n. Por ejemplo, el 13 es un número feliz primo. - Números descompuestos en cuadrados de números.
Se ha visto que, luego de elevar algunos números al cuadrado, sus dígitos pueden ser ordenados en grupos de tal modo que cada grupo es un cuadrado. Por ejemplo,
72 = 49, con grupos (4)(9), (22)(32)
132 = 169, con grupos (16)(9) = (42)(32)
382 = 1444, con grupos (144)(4) = (122)(22)
2232 = 49729, con grupos (49)(729) = (72)(272)
(Posamenter & Lehmann, 2014, pag 50)
Construya un programa Python que indague por más números. Indague sólo para el primer millón de números enteros. - Números descompuestos en potencias n de números.
Se ha visto que, luego de elevar algunos números al cuadrado, sus dígitos pueden ser ordenados en grupos de tal modo que cada grupo es un cuadrado. (Ver el problema anterior). Entra la duda, entonces, de si se puede hacer lo mismo con otras potencias mayores a 2.
Construya un programa Python que indague por números sobre los que se pueda agrupar dígitos, y cuyos grupos sea potencias de un número n entre 3 y 9. Indague sólo para el primer millón de números enteros. - Suma con aritmética arbitraria.
Construya una función Python que reciba dos números enteros representados como string, y los sume sin usar funciones Python de conversión de strings a números. Use técnica que usted aprendió en la escuela, de sumar dígitos y hacer acarreos a la siguiente suma de dígitos. - Resta con aritmética arbitraria.
Construya una función Python que reciba dos números enteros representados como string, y reste el segundo del primero, sin usar funciones Python de conversión de strings a números. Use técnica que usted aprendió en la escuela, de restar dígitos y hacer acarreos a la siguiente suma de dígitos. - La hormiga maria bitolia de bitlandia.
Una hormiga bitlandesa de tamaño obviamente bitlandés llamada maria bitolia, dedica su vida al ocio estilo bitlandés. Durante ratos de aburrimiento, le gusta patinar los caracteres de cadenas de texto. Cada que lo hace, determina el tiempo que le toma ir del comienzo de la cadena al final, y aunque nunca ha entendido porqué cambia el tiempo que toma en recorrer cadenas del mismo tamaño, ve divertido el proceso. Desde una perspectiva macro, en realidad lo que está pasando es que, a medida que se mueve entre las letras, la representación binaria de cada caracter acelera o desacelera la hormiga, ya que una hormiga bitlandesa tiene células con material ferromagnético en la base de las yemas de los dedos de sus pies, y se siente como si estuviera patinando, y de ahí que maria bitolia encuentre tan divertido caminar por archivos de texto.
El archivo de texto está compuesto de caracteres cuyo código la tabla básica no extendida de códigos ASCII entre 0 y 127 sin tener en cuenta tildes. Por ejemplo, si el archivo de texto contiene el fragmento "En algun lugar de la mancha" (nota: aunque la palabra algún lleva tilde, la hemos eliminado para reducir el set de caracteres ascii), contiene los códigos 69 110 32 97 108 103 117 110 32 108 117 103 97 114 32 100 101 32 108 97 32 109 97 110 99 104 97. En Python, para obtener el código de un caracter, puede usar la función ord().
Estos códigos, a su vez, están representados como números binarios, por lo que, en realidad, el texto en códigos de 8 bits es 01000101 01101110 0100000 01100001 01101100 01100111 01110101 01101110 0100000 01101100 01110101 01100111 01100001 01110010 0100000 01100100 01100101 0100000 01101100 01100001 0100000 01101101 01100001 01101110 01100011 01101000 01100001
(los espacios en blanco son sólo para dar claridad).
Entonces la situación es la siguiente para maria bitolia mientras recorre el archivo de texto, donde moverse entre cada bit le toma fracciones de segundo condicionadas así:
-Entrar al primer bit del archivo o salir del archivo, le toma a maria bitolia ½ segundo.
-Cuando maria bitolia está en alguno de los otros bits, el tiempo que le toma pasar al siguiente va a depender del bit de adelante y atrás, lo que genera 8 situaciones binarias:
000, pasar de cero a cero, dado que le precede cero. tiempo 1 segundo.
001, pasar de cero a uno, dado que le precede cero. tiempo 7/8 segundo.
010, pasar de uno a cero, dado dado que le precede cero. tiempo 6/8 segundo.
011, pasar de uno a uno, dado dado que le precede cero. tiempo 5/8 segundo.
100, pasar de cero a cero, dado dado que le precede uno. tiempo ½ segundo.
101, pasar de cero a uno, dado dado que le precede uno. tiempo 3/8 segundo.
110, pasar de uno a cero, dado dado que le precede uno. tiempo 2/8 segundo.
111, pasar de uno a uno, dado dado que le precede uno. tiempo 1/8 segundo.
Construya un programa Python que determine, dada una cadena de caracteres ascii no extendida (códigos 0-127), le tiempo que le toma a maria bitolia patinarla. - Peso Molecular. [QUI]
Construya una función Python que reciba una string que representa una molécula química. Los elementos se representan con letras mayúsculas y minúsculas. Un número a la derecha de cada elemento representa el número de átomos del elemento. Determine el peso molecular de la molécula. Por ejemplo,
C6H12O6 tiene un peso molecular de 12.01 x 6 + 1.01 x 12 + 16.0 x 6 = 180.18 g/mol.
NaOH tiene un peso molecular de
(Stephenson, 2016) 22.99 + 16.00 + 1.01 = 40.00 - Multiplicación con aritmética arbitraria.
Construya una función Python que reciba dos números enteros representados como string, y los multiplique, sin usar funciones Python de conversión de strings a números. Use técnica que usted aprendió en la escuela, de multiplicar dígitos y hacer acarreos. - División con aritmética arbitraria.
Construya una función Python que reciba dos números enteros representados como string, y divida el primero sobre el segundo, sin usar funciones Python de conversión de strings a números. Use técnica que usted aprendió en la escuela, de multiplicar dígitos y hacer acarreos. - Evaluador de expresiones con suma y resta.
Construya una función Python que reciba una string que representa una expresión aritmética compuesta de números que se suman y restan. La función deberá evaluar la expresión. Entre los números hay máximo un operador aritmético más(+) o menos(-), y entre los operadores y los operandos pueden habar espacios en blanco. Por ejemplo,
la expresión es 22.99 +16.00-1.01 da 37.89. - Compresión de Genoma. [BIO]
Una secuencia genómica de ADN se desea compactar en bits, de tal modo que cada 8 bits representen un byte y cada byte se lleve a un caracter ascii. La cadena final almacenada será otra string. A las letras del genoma se les dará un código entre 0 y 3, por ejemplo, A=0, T=1, C=2, G=3, lo que genera las posibles secuencias binarias 00, 01, 10, 11.
Si juntamos los 4 pares en un nuevo número binario, la secuencia 00011011, que corresponde al número decimal 27, equivaldría a la secuencia genética ACGT, que podremos almacenar en un solo byte, y por tanto, en un solo caracter. Eso significa que en un solo byte, se pueden almacenar cuatro nucleótidos cualquiera en sus 4 posibilidades, desde AAAA que corresponde a 00000000 que es 0, hasta GGGG que corresponde a 11111111 255.
Según lo anterior, una cadena larga de ADN, se procesaría cada 4 nucleótidos, y esos 4 nucleótidos se llevarían a un byte, y así sucesivamente. Por ejemplo: ACGGTGTGACGTGAGCGCG se fragmentaría en:
ACGG pasa como 00101111 que es 47 equivale al ascii ‘/’
TGTG pasa como 01110111 que es 119 equivale al ascii ‘w’
ACGT pasa como 00101101 que es 45 equivale al ascii ‘-’
GAGC pasa como 11001110 que es 206 equivale al ascii ‘Î’
GCG pasa como 11101100 que es 236 equivale al ascii ‘ì’
Por lo tanto, la cadena ‘ACGGTGTGACGTGAGCGCG’de 19 caracteres, cambia a la cadena‘/w-Îì’que solo contiene 5 caracteres, reduciéndose por compresión a un 26.31% de la cadena original.
Construya una función Python que lea una string que representa una secuencia de ADN en la que se garantiza solo vienen las cuatro letras ACGT en cada caracter, y lleve la secuencia a una cadena ascii. - Peso molecular proteína. [BIO]
Dada una string que representa una secuencia de aminoácidos, construya una función que calcule su peso molecular total, a través de la suma de los pesos individuales de sus aminoácidos. El peso molecular de cada uno de sus aminoácidos se encuentra definido en gramos por mole. A continuacuón se presenta un diccionario con los valores de pesos en gramos por mole de cada uno de los aminoácidos.
{"A":89.1, "R":174.2, "N":132.1, "D":133.1, "C":121.2, "E":147.1, "Q":146.2, "G":75.1, "H":155.2, "I":131.2, "L":131.2, "K":146.2, "M":149.2, "F":165.2, "P":115.1, "S":105.1, "T":119.1, "W": 204.2, "Y":181.2, "V": 117.1} - Etiquetador de Cajas de fósiles.
En un museo de arqueología se almacena en estanterías fósiles en cajas de cartón que deben ser etiquetadas según estantería, fila y columna dentro de la estantería. Las estanterías son consecutivas y van marcadas con letras comenzando en la letra 'A'. Todas las estanterías contienen el mismo número de filas que de columnas: N filas por M columnas: esto es, cada estantería alberga N x M fósiles. Cuando las estanterías pasan de la letra ‘Z’, se comienzan a etiquetar con dos letras, de tal modo que le sigue la estantería‘AA’, ‘AB’, ‘AC’,….
El código de cada etiqueta corresponde a la o las letras de la estantería, y a la fila, columna que ocupe el fósil. Por ejemplo, el consecutivo para la caja de fósil en la estantería ‘A’ en la fila 1, columna 1, marca ‘A-1-1’. El código ‘ZX-6-22’corresponde a la estantería ‘ZX’, fila 6, columna 22.
Los números de fila y columna están limitados a los valores M x N que definen el tamaño de las estanterías.
Los fósiles son enumerados a medida que llegan (1,2,3,4,…), y ya el museo cuenta con varios cientos de miles de ellos. Cuando llega un fósil, se le da un consecutivo, y se genera la etiqueta adecuada, proceso que ha demostrado ser riesgos hacerlo a mano, por lo que se decidió automatizarlo. Construya una función Python que reciba el tamaño de las estanterías N y M, y un número entero que es el número de un fósil. La función da como salida la etiqueta que le corresponde. - Menor y mayor de lista.
Dada una lista Python, construya una función llamada menor(), que devuelva una tupla con dos elementos, el menor y el mayor. - Ascendente.
Dada una lista Python, determine si se encuentra ordenada ascendentemente. - Ascendente o Descendentemente.
Dada una lista Python, determine si se encuentra ordenada ascendente o descendentemente. La función devuelve -1 si el orden es descendente o 1 si el orden es ascendente. Si no hay un orden establecido, devuelve 0. - Peajes.
Se cuenta con una matriz repesentada con listas. Cada fila contiene en cada celda una tupla con valor de peaje y número de kilómetros recorridos hasta el peaje. Construya una función Python que reciba la matriz, y determine la fila con el valor por kilómetro más bajo, y la fila con el valor por kilómetro más alto. Los dos valores deberán devolverse como una tupla. - Cuántas hojas se perdieron.
Se cuenta con una lista que contiene números de página extraviados de un libro. Construya una función Python que determine cuántas hojas se perdieron. La primera hoja arranca la numeración en 1, y todas las páginas tienen número. Por ejemplo,
si se perdieron la 1 3 4 7 8 19 y 223, el análisis es:
la página 1 va aparte, la página 3 y 4 van juntas, la 7 y 8 juntas, y la 223 es aparte. Por lo tanto, se perdieron en total 4 páginas. - Cuántas hojas se perdieron en la biblioteca.
Se cuenta con un diccionario donde las claves son el código de los libros. El valor de cada entrada en el diccionario es una lista que contiene números de página extraviados de un libro. Muchos libros están en perfecto estado. Construya una función Python que determine cuántas hojas se perdieron por cada uno de los libros. El resultado es otro diccionario con las mismas claves, pero con el total de hojas extraviadas. En el nuevo diccionario sólo se incluyen los libros que tienen pérdida de hojas. Por ejemplo, si a un libro se le perdieron la 1 3 4 7 8 19 y 223, el análisis es: la página 1 va aparte, la página 3 y 4 van juntas, la 7 y 8 juntas, y la 223 es aparte. Se perdieron en total 4 páginas. - Posición del menor número cercano.
Dada una lista de números desordenados, determinar la posición del número más cercano a un número dado, que sea menor al número. Si el número no existe, se devuelve -1. Por ejemplo:
para [1,2,3,8,2,6,3,6,3,45,2,5,6,90] y 10, devuelve 3
para [45,12,15,16,90] y 10, devuelve -1 - Suma de menores.
Dada una lista de números enteros desordenados y un numero entero, determinar la suma de los números menores que sea menor al número. Si el número no existe, se devuelve -1. Por ejemplo:
para [1,2,3,8,2,6,3,6,3,45,2,5,6,90] y 10, devuelve 3
para [45,12,15,16,90] y 10, devuelve -1 - Menor y mayor de lista.
Dada una lista Python, construya una función llamada menor(), que devuelva una tupla con dos elementos, el menor y el mayor. - Ascendente.
Dada una lista Python, determine si se encuentra ordenada ascendentemente. - Ascendente o Descendentemente.
Dada una lista Python, determine si se encuentra ordenada ascendente o descendentemente. La función devuelve -1 si el orden es descendente o 1 si el orden es ascendente. Si no hay un orden establecido, devuelve 0. - Peajes.
Se cuenta con una matriz repesentada con listas. Cada fila contiene en cada celda una tupla con valor de peaje y número de kilómetros recorridos hasta el peaje. Construya una función Python que reciba la matriz, y determine la fila con el valor por kilómetro más bajo, y la fila con el valor por kilómetro más alto. Los dos valores deberán devolverse como una tupla. - Cuántas hojas se perdieron.
Se cuenta con una lista que contiene números de página extraviados de un libro. Construya una función Python que determine cuántas hojas se perdieron. La primera hoja arranca la numeración en 1, y todas las páginas tienen número. Por ejemplo,
si se perdieron la 1 3 4 7 8 19 y 223, el análisis es:
la página 1 va aparte, la página 3 y 4 van juntas, la 7 y 8 juntas, y la 223 es aparte. Por lo tanto, se perdieron en total 4 páginas. - Cuántas hojas se perdieron en la biblioteca.
Se cuenta con un diccionario donde las claves son el código de los libros. El valor de cada entrada en el diccionario es una lista que contiene números de página extraviados de un libro. Muchos libros están en perfecto estado. Construya una función Python que determine cuántas hojas se perdieron por cada uno de los libros. El resultado es otro diccionario con las mismas claves, pero con el total de hojas extraviadas. En el nuevo diccionario sólo se incluyen los libros que tienen pérdida de hojas. Por ejemplo, si a un libro se le perdieron la 1 3 4 7 8 19 y 223, el análisis es: la página 1 va aparte, la página 3 y 4 van juntas, la 7 y 8 juntas, y la 223 es aparte. Se perdieron en total 4 páginas. - Posición del menor número cercano.
Dada una lista de números desordenados, determinar la posición del número más cercano a un número dado, que sea menor al número. Si el número no existe, se devuelve -1. Por ejemplo:
para [1,2,3,8,2,6,3,6,3,45,2,5,6,90] y 10, devuelve 3
para [45,12,15,16,90] y 10, devuelve -1 - Suma de menores.
Dada una lista de números enteros desordenados y un numero entero, determinar la suma de los números menores que sea menor al número. Si el número no existe, se devuelve -1. Por ejemplo:
para [1,2,3,8,2,6,3,6,3,45,2,5,6,90] y 10, devuelve 3
para [45,12,15,16,90] y 10, devuelve -1 - Suma de laterales.
Dada una lista de números desordenados, determinar la suma de los números a los lados de un número dado. Si el número no existe, se devuelve 0. Si el número está en un extremo, sólo se tiene en cuenta un lado. Por ejemplo:
para [1,2,3,8,2,6,3,6,3,45,2,5,6,90] y 10, devuelve 0
para [45,12,15,16,90] y 12, devuelve 60
para [45,12,15,16,90] y 45, devuelve 12 - Determinar si hay alguna repetición.
Dada una lista Python con números enteros, determinar si hay repeticiones. Por ejemplo,
para [1,2,7,5,12,8,92,13,13,17,78,78] devuelve True. - Determinar cuántas repeticiones hay.
Dada una lista Python con números enteros, determinar cuántos grupos de números repetidos hay. Por ejemplo,
para [1,2,7,5,12,8,92,13,13,17,78,78] devuelve 2. - Determinar primera posición repetición.
Dada una lista Python con números enteros, determinar la posición de la primera repetición. Si no hay repeticiones, devuelve -1.
para [1,2,7,5,12,8,92,13,13,17,78,78] devuelve 7.
para [1,2,7,4,66,5,12,8,92,13,17,78] devuelve -1. - Determinar última posición repetición.
Dada una lista Python con números enteros, determinar la posición de la última repetición. Si no hay repeticiones, devuelve -1.
para [1,2,7,5,12,8,92,13,13,17,78,78] devuelve 10.
para [1,2,7,4,66,5,12,8,92,13,17,78] devuelve -1. - Determinar posiciones repeticiones.
Dada una lista Python con números enteros, determinar las posiciones de las repeticiones. Si no hay repeticiones, devuelve [].
para [1,2,7,5,12,8,92,13,13,17,78,78] devuelve [7,10].
para [1,2,7,4,66,5,12,8,92,13,17,78] devuelve []. - Borrar repetidos.
Dada una lista Python con números enteros, borrar los repetidos, de tal forma que sólo quede uno de ellos. Por ejemplo,
para [5,12,8,92,13,13,17,78,78] devuelve [5,12,8,92,13,17,78]. - Suma de datos según posiciones I.
Se cuenta con dos listas. Una lista con datos, y otra con posiciones. La lista que contiene posiciones, indica qué elementos de la lista de datos se debe sumar. Construya una función Python que reciba las dos listas y devuelva la suma de dichas posiciones. Por ejemplo:
posiciones: [1,7,17]
datos: [1,2,8,2,6,2,7,90,3,7,35,66,83,4437,3,7,4,63,5,63,6,2878,7,5567,8,37,3,7,3,7]
el resultado de la función es 155. - Suma de datos según posiciones II.
Se cuenta con dos listas. La primera lista es una lista de listas de posiciones. La segunda es una lista con datos. Se cuenta con un tercer valor que identifica cuál es la lista de posiciones se debe usar. Construya una función Python que reciba las dos listas y un número y devuelva la suma. Por ejemplo:
lista posiciones = 2
posiciones: [[4,5,9,22],[1,7],[7,9,14],[5,7,8,2]]
datos: [1,2,8,2,6,2,7,90,3,7,35,66,83,4437,3,7,4,63,5,63,6,2878,7,5567,8,37,3,7,3,7]
el resultado de la función es 100. - Centro comercial y Covid-19.
Se cuenta con un diccionario Python cuyas claves son cédulas, y cuyo valor es una tupla que contiene los valores (día, mes, hora, minuto, temperatura), medidas durante la pandemia del 2020 en un centro comercial. Construya una función Python que devuelva un nuevo diccionario cuya clave es el año, y cuyo valor es una lista de 12 posiciones, donde cada posición contiene el total de lecturas con temperatura mayor o igual 37.5. - Genoma Sanger. [BIO]
Durante un proceso de secuenciamiento Sanger, en el que se leen fragmentos de ADN desde el genoma de un organiso prokariote o eukariote, para cada nucleótido A, C, G o T se genere un valor de calidad.
Dado que al comienzo del proceso y al fin de la secuencia normalmente la calidad es baja, se desea buscar el sector de la cadena con mayor calidad.
Se presume que el sector con mayor calidad es aquel que tenga un promedio de valores mayor entre los nucleótidos proximales, por lo que se puede asumir un número n para la ventana o conjunto de nucleótidos a los que se les sacará el promedio.
Dado n como ventana, y una lista de valores numéricos que representan la calidad de una secuencia, determine el centro de la mejor ventaja, esto es, la posición de la lista que está en el centro de n números con el mejor promedio. Un promedio se define como la sumatoria de los valores, dividido por el tamaño de la ventana.
Por ejemplo,
para n=3 y [1,2,3,5,5,4,2,1], las ventanas y sus promedios son:
1+2+3= 6/3 = 2.0
2+3+5= 10/3 = 3.33
3+5+5= 13/3 = 4.33
5+5+4= 14/3 = 4.66
5+4+2 = 11/3 = 3.66
4+2+1 = 7/3 = 2.33
El mayor es 4.66, que equivale a la ventana 5,5,4. El centro es la posición 4 dentro de la lista. Por lo tanto, la función devuelve 4.
Trabaje solo con dos cifras decimales. Para el efecto, use la función round( ) de Python.
En el caso que hallan varios centros, escoja el que se encuentra más cerca al centro de la lista. - Ordenar lista ascendentemente.
Elabore una función Python que reciba una lista desordenada, y la ordene ascendentemente. Ayuda: recorra cada elemento, y compárelo con todos los demás; si encuentra un menor, intercámbielo. - Ordenar lista ascendente o descendentemente.
Elabore una función Python que reciba una lista desordenada, y lo modifique para obtener un orden ascendente o descendente, según sea valor de un segundo parámetro. El segundo parámetro se llama asc, y si es verdadero, el orden es ascendente; de lo contrario, el orden es descendente. Ayuda: recorra cada elemento, y compárelo con todos los demás; si encuentra un menor, intercámbielo. - Mover a izquierda con relleno 0.
Construya una función Python que, dado un arreglo con números enteros, y dado un valor n, mueva los elementos a la izquierda n posiciones. Los n elementos más a la izquierda se pierden, y a la derecha se rellena con ceros.
Para [12,34,39,45,78,89], n = 1, devuelve [0, 12,34,39,45,78]
Para [12,34,39,45,78,89], n = 6, devuelve [0,0,0,0,0,0]
Para [12,34,39,45,78,89], n = 3, devuelve [0,0,0,12,34,39] - Mover a derecha con relleno específico.
Construya una función Python que, dado un arreglo con números enteros, y dado un valor n, mueva los elementos a la derecha n posiciones. Los n elementos más a la derecha se pierden, y a la izquierda se rellena con un número específico dado de relleno.
Para [12,34,39,45,78,89], n = 1, r = 10, devuelve [34,39,45,78,89,10]
Para [12,34,39,45,78,89], n = 6, r = 77, devuelve [77,77,77,77,77,77]
Para [12,34,39,45,78,89], n = 3, r = 42, devuelve [45,78,89,42,42,42 - Invertir dígitos de números en arreglo.
Construya una función Python que, dado un arreglo con números enteros, devuelva el arreglo con los dígitos de los números invertidos.
Para [12,34,39,45,78,89], devuelve [21,43,93,54,87,98] - Ordenar arreglo descendentemente.
Construya una función Python que, dado un arreglo con números enteros, devuelva el arreglo ordenado de forma descendente sin tener en cuenta los extremos.
Para [34,45,12,78,39,89], devuelve [34,78,45,39,12,89] - Crear lista set.
Construya una función Python que reciba dos listas que pueden contener elementos repetidos, y construya una tercera lista que sea la intersección en teoría de conjuntos, en la cual no puede haber elementos repetidos. Por ejemplo, para:
[1,2,7,3,7,3,7,6],[3,3,7,2,7,5,3,5] la respuesta es [2,3,7] - Unión.
Construya una función Python que reciba dos listas que pueden contener elementos repetidos, y construya una tercera lista que sea la unión en teoría de conjuntos, en la cual no puede haber elementos repetidos. Por ejemplo, para:
[1,2,7,3,7,3,7,6] , [3,3,7,2,7,5,3,5] la respuesta es [1,2,3,5,6,7] - Diferencia.
Construya una función Python que reciba dos listas que pueden contener elementos repetidos, y construya una tercera lista que sea la diferencia A-B en teoría de conjuntos, en la cual no puede haber elementos repetidos. La diferencia A-B se define como los elementos de A que no están en B. Por ejemplo, para:
[1,2,7,3,7,3,7,6],[3,3,7,2,7,5,3,5] la respuesta es [1,6] - Subconjunto.
Construya una función Python que reciba dos listas que pueden contener elementos repetidos, y construya una tercera lista que determine si los elementos de la primera lista están todos en la segunda lista. Por ejemplo, para:
[1,2,7,3,7,3,7,6],[3,3,7,2,7,5,3,5] la respuesta es .f. - Unión II.
Construya una función Python que reciba una lista que contiene listas que pueden contener elementos repetidos, y construya una tercera lista que sea la unión de conjuntos. Por ejemplo, para:
[[10,2,7],[3,7,3,70,6],[3,13],[7,2,5,3,15] la respuesta es [2,3,5,6,7,10,15,70] - Intersección II.
Construya una función Python que reciba una lista que contiene listas que pueden contener elementos repetidos, y construya una tercera lista que sea la intersección de todos los conjuntos. Por ejemplo:
para [[10,3,7],[3,7,3,70,6],[3,13],[7,2,5,3,15] la respuesta es [3]
para [[10,6,7],[3,7,3,70,6],[3,13],[7,2,5,3,15] la respuesta es [] - Matrix identidad.
Construya una función Python que reciba una lista que contiene n listas, cada lista con n elementos, y evalúe si se trata de una matriz identidad. Una matriz identidad es aquella que contiene unos en su diagonal principal. El resto de los elementos es cero. - Matriz triangular superior.
Construya una función Python que reciba una lista que contiene n listas, cada lista con n elementos y evalúe si se trata de una matriz triangular inferior, que es aquella que tiene todos los elementos por encima de la diagonal superior igual a cero. - Matriz triangular inferior.
Construya una función Python que reciba una lista que contiene n listas, y evalúe si se trata de una matriz triangular superior, que es aquella que tiene todos los elementos por debajo de la diagonal superior igual a cero. - Matriz simétrica.
Construya una función Python que reciba una lista que contiene n listas, cada lista de n elementos, y evalúe si se trata de una matriz simétrica, que es aquella en la que todo ai,j = aj,i. - Matriz Toeplitz.
Una matriz cuadrada cuyos elementos son constantes en todas sus diagonales, se le denomina matriz de Toeplitz. Construya una función Python que reciba una lista que contiene n listas, cada lista de n elementos, y evalúe si se trata de una matriz Toeplitz. (Zwillinger, 2018, p.85) - Intercambiar dos filas.
Dada una matriz en Python de MxN, y dados dos números que representan dos filas, Construya una función que intercambie los elementos de las filas. - Intercambiar fila por columna.
Dada una matriz cuadrada en Python, y dados dos números que representan el número de una fila y de una columna, construya una función que intercambie los elementos de la fila con los de la columna. - Matriz de Markov.
Se dice que una matriz es de Markov si la suma de los elementos de cada una de las columnas es 1.0. Construya una función Python que reciba una matriz de MxN, y diga si se trata de una matriz de Markov. (Zwillinger, 2018, p.88) - Vectores ortogonales.
Dos vectores se dice que son ortogonales, si al multiplicarlos elemento a elemento, la suma de los resultados es cero. Construya una función Python que determine si dos vectores son ortogonales. - Multiplicar matriz por escalar.
Construya una función Python que reciba una matriz, y un escalar, y multiplique la matriz por el escalar, de tal modo que Bij = x.Aij. La función devuelve la nueva matriz B. - Submatrices pares igual a impares.
Dada una matriz cuadrada (NxN) que contiene números enteros positivos, construya una función Python que permita determinar cuantas submatrices cuadradas con N > 1 y N par, hay que contiene tantos números pares como impares. Por ejemplo, en la matriz que se muestra, sólo se descubren 2 submatrices de 2x2 con esa características:
8 9 1 2
4 5 7 3
1 4 8 3 - diagonales en submatrices suman igual.
Dada una matriz cuadrada (NxN) que contiene números enteros positivos, construya una función Python que permita determinar cuantas submatrices cuadradas con N > 1 y N impar, hay que suman lo mismo en los elementos de sus diagonales. Por ejemplo, en la matriz que se muestra, sólo se descubren 3 submatrices de 2x2 con esa características:
8 9 1 2
4 5 7 2
1 2 8 3 - Cuadrilandia y los rines de bicicleta que giran 90 grados.
Cuadrilandia es un planeta cuadrado en una estrella cuadrada de la constelación de la Escuadra. Allí todo es cuadrado, y las ruedas cuadradas de las bicicletas, por ejemplo, sólo rotan en ciertos grados específicos adelante o atrás. A los cuadrilinenses les encantan las matrices, y, de hecho, las llantas de las bicicletas se construyen con matrices cuadradas de NxN celdas, donde cada una de sus celdas contiene valores precisos de la cantidad de moléculas de equilicuadro requeridas para equilibrios, con base en heurísticas de todas las carreras.
Los organizadores de las cuadricampeonatos de bicicleta, necesitan conocer, dado un número de grados múltiplo de 90 de las cuadrillantas al momento del paso por la meta, el estado de los equilicuadros, asumiendo un estado inicial para los mismos.
Construya un programa Python que, dada una matriz con valores enteros de equilicuadros, determine el estado final de dicha matriz conocido un ángulo de giro, el cual puede ser positivo o negativo.
Por ejemplo, para la matriz
1 2 3
4 5 6
7 8 9
rotaciones de +90 grados y de -90 grados, son respectivamente
7 4 1 3 6 9
8 5 2 2 5 8
9 6 3 1 4 7
Los datos de entrada del programa son la matriz cuadrada NxN y el ángulo.
Ejemplo, para los datos de entrada
10 18 14 19
M = 98 23 34 10 Ángulo = -710460
5 66 12 49
18 0 14 20
R/ Un ángulo -710460 corresponde a un ángulo de -180
(como cada rotación lleva a la misma matriz, sólo se rota -710460 % 360 = -180 grados). Entonces, para -180 grados, tenemos dos rotaciones de -90.
El primer giro a la izquierda corresponde a la matriz:
19 10 49 20
M = 14 34 12 14. (giro #1 a la izquierda)
18 23 66 0
10 98 5 18
Finalmente, el segundo giro a la izquierda corresponde a la matriz:
20 14 0 18
M = 49 12 66 5. (giro #2 a la derecha)
10 34 23 98
19 14 18 10 - Submatrices ceros.
Dada una matriz cuadrada (NxN) que contiene números enteros positivos y negativos, construya una función Python que permita determinar cuantas submatrices cuadradas con N > 1 hay que suman cero. La matriz completa no se podrá considerar submatriz. - Descuadre diagonal de matriz.
Elabore un programa en Python que, da una matriz cuadrada, y un número entero de descuadre d, modifique la matriz de tal modo que todo su contenido se mueva en filas y columnas el valor de descuadre. Las posiciones de los elementos que se movieron, quedan en ceros.
Por ejemplo, si la entrada es la matriz
| 10 20 30 40 |
| 50 60 70 80 |
| 90 100 110 120 |
|130 140 150 160 |
d = 2:
La salida de la función es
| 0 0 0 0 |
| 0 0 0 0 |
| 0 0 10 20 |
| 0 0 50 60 | - Custodia en las murallas de Saurón.
Los Uruk-hai fueron creados por Sauron a finales de la Tercera Edad y estaban claramente destinados a ser los súper soldados de los ejércitos del mal. De forma permanente, usted, como lider de custodia de las torres cuadradas, suma el número de orcos apostados en los muros para determinar que sea adecuado. El número es adecuado si la suma de los orcos en los bordes de la torre, es de al menos un x% del total de orcos en toda la torre. Dado que son muchas torres qué vigilar en el reino, y el tamaño de cada torre puede ser importante, usted decide modelar cada torre como una matriz cuadrada, done cada celda representa el número de orcos en cada sector. Los muros de las torres estarán representados por las celdas de los bordes de la matriz. Crear un programa en Python que cuente los guardias apostados en los muros de las torres cuadradas para determinar que la cantidad de orcos sea de al menos ese porcentaje. La salida del programa es un valor verdadero o falso. - Sumas equivalentes en filas o columnas.
Dada una matriz rectangular NxM que contiene números enteros positivos y negativos, construya una función Python que permita determinar si hay filas o columnas cuya suma de sus números de lo mismo. La respuesta se deberá ser una tupla, donde cada elemento de la tupla es otra tupla en la que se indica el valor de la suma, y las filas y columnas que suman lo mismo, las filas en una lista, y las columnas en otra lista.
Por ejemplo, para:
8 5 3 3 7
4 2 4 3 8
1 5 5 5 2
2 8 2 4 10
suman 15 las columnas 1,4 y la fila 3, y suman 26 las filas 1 y 4, por lo que la respuesta deberá ser
( ( 26 , [1,4], [] ), ( 15 , [3] , [1,4] ) - Caja fuerte digital.
Este problema es uno de los que siempre aparecen en los test de Mensa.Se trata de matrices de NxM que representan el teclado de una caja fuerte. Cada celda de la matriz representa un botón de la puerta de la caja. El botón F, que aparece en alguna de las celdas, es el último botón que se presiona. Todos los demás se deben presionar en un orden específico. Cada celda contiene información (no visible al usuario) de cuál botón se presiona a continuación.
Por ejemplo, la matriz Python
[["3D","4B","2I","2I","2B"],
["3D","3D","3B","2I","2B"],
["1D","1B","F", "3I","2I"],
["2A","1I","3A","1A","2I"],
["4D","1I","1D","1A","4A"] ]
representa un teclado de caja una caja fuerte, en el que la letra F, que es donde finaliza la secuencia de apertura, está en la celda (2,2). Cada celda de la matriz contiene una string que representa el siguiente botón en la secuencia de apertura. La letras A, B, I, D, representan respectivamente las direcciones Arriba, aBajo, Izquierda y Derecha.
El número que acompaña a la letra, indica el número de celdas en la dirección donde se encuentra el siguiente botón a presionar.
Construya un programa Python que reciba la matriz de entrada, y emita una lista con las posiciones de los botones a presionar desde el primero. Para el ejemplo que se plantea, la secuencia de salida es una lista de tuplas indicando la fila y columna del botón, desde el primero que se pulsa, hasta la letra F, y es:
[(1, 2), (4, 2), (4, 3), (3, 3), (2, 3), (2, 0), (2, 1), (3, 1), (3, 0), (1, 0), (1, 3), (1, 1), (1, 4), (3, 4), (3, 2), (0, 2), (0, 0), (0, 3), (0, 1), (4, 1), (4, 0), (4, 4), (0, 4), (2, 4), (2, 2)] - Sopa de letras.
Construya una función Python que dada una lista de palabras y una matriz en la que aparece en cada celda un número entero que es un código ascii correspondiente a una letra mayúscula entre ‘A’ a ‘Z’, busque las palabras y determinar su posición inicial y posicion final dentro de la matriz. La posiciones deberán entregarse de tal forma que primero se indica la posición (fila,columna) de la letra inicial de la palabra, y segundo la posición de la letra final. En la matriz, las palabras podrán venir en filas, columnas, o diagonales, y podrán venir invertidas. El resultado se entrega como una lista de tuplas, en la que en cada tupla aparece la palabra, la posición inicial, y la posición final. - Escuadrilandia y los rines de bicicleta que giran 45 grados.
Escuadrilandia es un planeta cuadrado, que al igual que Cuadrilandia, orbita la estrella cuadrada de la constelación de la Escuadra. En esos planetas todo es cuadrado. En Escuadrilandia y en Cuadrilandia, las ruedas cuadradas de las bicicletas son cuadradas y sólo rotan en ciertos grados específicos adelante o atrás. A los escuadrilinenses también les encantan las matrices, y, al igual que los cuadrilenses, las llantas de las bicicletas las construyen con matrices cuadradas de NxN celdas, donde cada una de sus celdas contiene valores precisos de la cantidad de moléculas de equilicuadro requeridas para equilibrios, con base en heurísticas de todas las carreras.
Los organizadores de las escuadricampeonatos de bicicleta, necesitan conocer, dado un número de grados múltiplo de 45 de las cuadrillantas al momento del paso por la meta, el estado de los equilicuadros, asumiendo un estado inicial para los mismos.
Nota: los cuadrilenses usan 90 grados pero en escuadrilandia son más exigentes con las mediciones.
Construya un programa Python que, dada una matriz con valores enteros de equilicuadros, determine el estado final de dicha matriz conocido un ángulo de giro, el cual puede ser positivo o negativo.
Por ejemplo, para la matriz
1 2 3
4 5 6
7 8 9
rotaciones de +45 grados y de -45 grados, son respectivamente
4 1 2 2 3 6
7 5 3 1 5 9
8 9 6 4 7 8
Los datos de entrada del programa son la matriz cuadrada NxN y el ángulo.
Ejemplo, para los datos de entrada
10 18 14 19
M = 98 23 34 10 Ángulo = +710415
5 66 12 49
18 0 14 20
R/ Un ángulo +710415 corresponde a un ángulo de +135
(como cada rotación lleva a la misma matriz, sólo se rota +710415 % 360 = +135 grados). Entonces, para +135 grados, tenemos tres (3) rotaciones de 45.
El primer giro a la derecha corresponde a la matriz:
98 10 18 14
M = 5 23 34 19 (giro #1 a la izquierda)
18 66 12 10
0 14 20 49
El segundo giro a la derecha corresponde a la matriz:
5 98 10 18
M = 18 66 23 14 (giro #2 a la derecha)
0 12 34 19
14 20 49 10
El tercer y último giro a la derecha corresponde a la matriz:
18 5 98 10
M = 0 12 66 18 (giro #3 a la derecha)
14 34 23 14
20 49 10 19 - Rey de Ajedrez movimiento completo.
Se cuenta con una matriz representada por listas en Python. Cada posición puede estar vacía, lo que se representa con una string vacía, o puede contener el nombre de alguna pieza, lo que se representa con la inicial de la pieza seguida de B o N según sean blanca o negra la pieza. Construya una función Python que reciba un tablero, busque los reyes, y devuelva las letras 'B', 'N', o ambas, si hay algún rey libre de movimiento completo. El rey se representa como 'RB’o 'RN'. Un rey tiene movimiento completo si se puede mover como lo indica el ejemplo de la figura abajo. Los reyes pueden estar en cualquier posición. - Torre de Ajedrez movimiento completo.
Se cuenta con una matriz representada por listas en Python. Cada posición puede estar vacía, lo que se representa con una string vacía, o puede contener el nombre de alguna pieza, lo que se representa con la inicial de la pieza seguida de B o N según sean blanca o negra la pieza. Construya una función Python que reciba un tablero, busque las torres, y devuelva las letras 'B', 'N', o ambas, si hay alguna torre libre de movimiento completo. La torre se representa como 'TB’o 'TN'. Una torre tiene movimiento completo si se puede mover como lo indica el ejemplo de la figura abajo. Las torres pueden estar en cualquier posición. - Alfil de Ajedrez movimiento completo.
Se cuenta con una matriz representada por listas en Python. Cada posición puede estar vacía, lo que se representa con una string vacía, o puede contener el nombre de alguna pieza, lo que se representa con la inicial de la pieza seguida de B o N según sean blanca o negra la pieza. Construya una función Python que reciba un tablero, busque los alfiles, y devuelva las letras 'B', 'N', o ambas, si hay algún alfil libre de movimiento completo. El alfil se representa como 'AB’o 'AN'. Un alfil tiene movimiento completo si se puede mover como lo indica el ejemplo de la figura abajo. Los alfiles pueden estar en cualquier posición. - Reina de Ajedrez movimiento completo.
Se cuenta con una matriz representada por listas en Python. Cada posición puede estar vacía, lo que se representa con una string vacía, o puede contener el nombre de alguna pieza, lo que se representa con la inicial de la pieza seguida de B o N según sean blanca o negra la pieza. Construya una función Python que reciba un tablero, busque las reinas, y devuelva las letras 'B', 'N', o ambas, si hay alguna reina libre de movimiento completo. La reina se representa como 'QB’o 'QN'. Una reina tiene movimiento completo si se puede mover como lo indica el ejemplo de la figura abajo. Las reinas pueden estar en cualquier posición. - Caballo de Ajedrez movimiento completo.
Se cuenta con una matriz representada por listas en Python. Cada posición puede estar vacía, lo que se representa con una string vacía, o puede contener el nombre de alguna pieza, lo que se representa con la inicial de la pieza seguida de B o N según sean blanca o negra la pieza. Construya una función Python que reciba un tablero, busque los caballos, y devuelva las letras 'B', 'N', o ambas, si hay algún caballo libre de movimiento completo. El caballo se representa como 'CB’o 'CN'. Un caballo tiene movimiento completo si se puede mover como lo indica el ejemplo de la figura. Los alfiles pueden estar en cualquier posición. - ¿Puede moverse el rey?
Considerando los movimientos de las piezas como se mostró en las gráficas de los problemas anteriores. Ahora considere que el rey desea moverse, como se muestra en la figura de este problema. Construya una función Python que reciba un tablero que contiene fichas blancas y negras, busque el rey blanco y el rey negro, y revise si alguna de sus posiciones circundantes está siendo atacada por alguna pieza enemiga, sea peón, caballo, alfil, torre, rey o dama. El programa deberá devolver la lista de piezas atacantes y sus posiciones en el tablero.
ARCHIVOS DE TEXTO
En Python, se deberá tener claridad sobre el concepto de byte.
Un byte representa 8 bits.
Eso significa la posibilidad de trabajar con un set de caracteres limitado.
Sin embargo, Python procesa los archivos por defecto en un formato denominado UTF-8, en el cual se pueden representar muchos más caracteres de los que son posibles en 8 bits.
Esto se debe a que la especificación UTF-8 amplía el número de bytes hasta 4, usa bits de marca especiales, y usa el resto de bits para representar caracteres.
La cantidad posible de caracteres que pueden ser representados excede el millón, para un total de 1 112 064 caracteres posibles ("UTF-8", 2020). Eso es suficiente incluso para representar todos los caracteres de los lenguajes oficiales del mundo.
Dicho lo anterior, si un archivo no está en UTF-8, se le deberá especificar el otro formato.
A estos formatos se les conoce como ENCODINGS, y no se detallan en este libro.
Para archivos de texto, asumiremos un trabajo estándar con UTF-8 en lo que viene de aquí en adelante.
ARCHIVOS DE TEXTO
La mejor forma de comenzar con archivos de texto en Python es usar las funciones de ayuda disponibles en la librería __builtins__. Eso se debe a que, por lo general, las funciones ‘helper’[1] disponibles son suficientes para crear muchos algoritmos útiles, lo que evita que tengamos que conocer todos los detalles internos de Python para lograrlo.
MODOS DE APERTURA
Existen atributos de archivo al momento de abrirlo. Estos atributos son combinaciones de caracteres que informan a Python del modo en que se quiere abrir un archivo. Por ejemplo, para abrir un archivo para escribir en él, se usa alguno de los atributos 'a' o 'w'.
El significado puede variar dependiendo de si el archivo existe o no, ya que, si existe y se usa 'w', se reescribirá y se perderá la información. Y si se especifica 'a' existiendo el archivo, se podrá seguir adicionando sin perder información.
Los posibles atributos son combinaciones de los caracteres 'r', 'w', 'a', que indica que se va a leer('r'-ead), o a escribir ('w'-rite) en el archivo, o a anexar ('a'-ppend) nuevos datos.
También podríamos especificar el caracter '+', que especifica que la operación contraria también se acepta: 'r+' especifica leer y también escribir, mientras que 'w+' especifica escribir, pero también leer, y 'a+' indica anexar y poder leer.
Existen otras combinaciones, y se sugiere conocerlas para no caer en omisiones, redundancias, o errores.
ABRIR UN ARCHIVO
Para abrir un archivo en Python, se usa la función open( ) disponible en __builtins__. Es tan simple como llamar la función con la ruta del archivo, y el modo de apertura como se explicó previamente.
handle = open(rutadearchivo, modo)
Un archivo que se abre, se debe, preferiblemente, cerrar. Si no se cierra, el archivo puede quedar abierto, hasta que el ‘garbaje collector’ de Python, se encarga de cerrarlo al notar el abandono.
Por supuesto, hay formas más especializadas de abrir un archivo, de tal modo que cerrarlo no sea una preocupación. Eso se logra con la palabra reservada with de Python.
Para efectos de hacer un buen manejo de los recursos, use la instrucción open( ) con la sentencia with. Esta instrucción cierra automáticamente el archivo tan pronto termine el bloque with. Para obtener el ‘handle’ o manejador del archivo, use la palabra reservada as.
with open(rutadearchivo, modo) as handle:
bloque de código
Si se llega a dar un error en el procesamiento del archivo, o si se llega al final del bloque de código asociado bajo el with, el archivo se cierra automáticamente para evitar corrupción (daño).
La variable handle referencia el objeto gestor del archivo.
Para efectos de usar el archivo de este punto en adelante, deberá usar esa variable.
Tan pronto se abre el archivo, y si el archivo no está vacío, el modo será el que indique si el puntero del gestor handle está al comienzo o al final del archivo.
CREAR UN ARCHIVO
De los modos de apertura, se ve que, para abrir un archivo para escribir en él, se usa alguno de los atributos 'a' o 'w'. En este caso, si el archivo no existe, se crea. De ese modo, una operación de apertura será suficiente para crear un archivo, en caso de que no exista.
Cerrar un archivo Python.
Si un archivo no se abrió con with, se deberá usar la función close( ) para cerrarlo. Esta función, al contrario de open( ), no está disponible en la librería __builtins__. Para cerrar un archivo abierto, se invoca el método close( ) del ‘handle’.
Si se está usando la sentencia with, no es necesario usar close( ), pues cuando se sale del bloque with el archivo estará cerrado. En cualquier caso, intentar cerrar un archivo cerrado no genera error, algo que es muy conveniente.
No cerrar un archivo tiene el inconveniente del consumo de memoria, y buffers que pueden no ser enviados a disco y dejar el archivo incompleto.
LEER UN ARCHIVO
La lectura se puede hacer de muchas formas, y va a depender de la intención.
Para el efecto, podemos usar los métodos del objeto handle.
El método read( ) lee grupos de caracteres, incluso el archivo completo.
El método readline( ) lee una línea completa incluido el salto de linea.
EL método readlines( ) lee todo el archivo, dejando cada línea en una posición de una lista.
Cargar todo el archivo en memoria puede ser riesgoso, pues se debe estar seguro de que la memoria es suficiente. Es recomendable conocer con antelación las proporciones de los archivos que desea leer completamente en memoria, para no incurrir en errores de carga, o penalizaciones de los procesos.
De otro lado, y si quiero leer línea a línea, el archivo deberá contar con saltos de línea: caracter 10 (\n) en sistemas Unix y Linux, o caracter 10 y 13(\n\r) en Windows.
[1] Una función ‘helper’ es una función de librería que apoya la ejecución de otras funciones. La librería __builtins__ de Python contiene funciones que llaman métodos de otros objetos, para facilitar la escritura del código. Esta librería se carga siempre de forma automática, y las funciones ‘helper’ pueden ser invocadas sin necesidad de referirse a un objeto concreto.
Un byte representa 8 bits.
Eso significa la posibilidad de trabajar con un set de caracteres limitado.
Sin embargo, Python procesa los archivos por defecto en un formato denominado UTF-8, en el cual se pueden representar muchos más caracteres de los que son posibles en 8 bits.
Esto se debe a que la especificación UTF-8 amplía el número de bytes hasta 4, usa bits de marca especiales, y usa el resto de bits para representar caracteres.
La cantidad posible de caracteres que pueden ser representados excede el millón, para un total de 1 112 064 caracteres posibles ("UTF-8", 2020). Eso es suficiente incluso para representar todos los caracteres de los lenguajes oficiales del mundo.
Dicho lo anterior, si un archivo no está en UTF-8, se le deberá especificar el otro formato.
A estos formatos se les conoce como ENCODINGS, y no se detallan en este libro.
Para archivos de texto, asumiremos un trabajo estándar con UTF-8 en lo que viene de aquí en adelante.
ARCHIVOS DE TEXTO
La mejor forma de comenzar con archivos de texto en Python es usar las funciones de ayuda disponibles en la librería __builtins__. Eso se debe a que, por lo general, las funciones ‘helper’[1] disponibles son suficientes para crear muchos algoritmos útiles, lo que evita que tengamos que conocer todos los detalles internos de Python para lograrlo.
MODOS DE APERTURA
Existen atributos de archivo al momento de abrirlo. Estos atributos son combinaciones de caracteres que informan a Python del modo en que se quiere abrir un archivo. Por ejemplo, para abrir un archivo para escribir en él, se usa alguno de los atributos 'a' o 'w'.
El significado puede variar dependiendo de si el archivo existe o no, ya que, si existe y se usa 'w', se reescribirá y se perderá la información. Y si se especifica 'a' existiendo el archivo, se podrá seguir adicionando sin perder información.
Los posibles atributos son combinaciones de los caracteres 'r', 'w', 'a', que indica que se va a leer('r'-ead), o a escribir ('w'-rite) en el archivo, o a anexar ('a'-ppend) nuevos datos.
También podríamos especificar el caracter '+', que especifica que la operación contraria también se acepta: 'r+' especifica leer y también escribir, mientras que 'w+' especifica escribir, pero también leer, y 'a+' indica anexar y poder leer.
Existen otras combinaciones, y se sugiere conocerlas para no caer en omisiones, redundancias, o errores.
ABRIR UN ARCHIVO
Para abrir un archivo en Python, se usa la función open( ) disponible en __builtins__. Es tan simple como llamar la función con la ruta del archivo, y el modo de apertura como se explicó previamente.
handle = open(rutadearchivo, modo)
Un archivo que se abre, se debe, preferiblemente, cerrar. Si no se cierra, el archivo puede quedar abierto, hasta que el ‘garbaje collector’ de Python, se encarga de cerrarlo al notar el abandono.
Por supuesto, hay formas más especializadas de abrir un archivo, de tal modo que cerrarlo no sea una preocupación. Eso se logra con la palabra reservada with de Python.
Para efectos de hacer un buen manejo de los recursos, use la instrucción open( ) con la sentencia with. Esta instrucción cierra automáticamente el archivo tan pronto termine el bloque with. Para obtener el ‘handle’ o manejador del archivo, use la palabra reservada as.
with open(rutadearchivo, modo) as handle:
bloque de código
Si se llega a dar un error en el procesamiento del archivo, o si se llega al final del bloque de código asociado bajo el with, el archivo se cierra automáticamente para evitar corrupción (daño).
La variable handle referencia el objeto gestor del archivo.
Para efectos de usar el archivo de este punto en adelante, deberá usar esa variable.
Tan pronto se abre el archivo, y si el archivo no está vacío, el modo será el que indique si el puntero del gestor handle está al comienzo o al final del archivo.
CREAR UN ARCHIVO
De los modos de apertura, se ve que, para abrir un archivo para escribir en él, se usa alguno de los atributos 'a' o 'w'. En este caso, si el archivo no existe, se crea. De ese modo, una operación de apertura será suficiente para crear un archivo, en caso de que no exista.
Cerrar un archivo Python.
Si un archivo no se abrió con with, se deberá usar la función close( ) para cerrarlo. Esta función, al contrario de open( ), no está disponible en la librería __builtins__. Para cerrar un archivo abierto, se invoca el método close( ) del ‘handle’.
Si se está usando la sentencia with, no es necesario usar close( ), pues cuando se sale del bloque with el archivo estará cerrado. En cualquier caso, intentar cerrar un archivo cerrado no genera error, algo que es muy conveniente.
No cerrar un archivo tiene el inconveniente del consumo de memoria, y buffers que pueden no ser enviados a disco y dejar el archivo incompleto.
LEER UN ARCHIVO
La lectura se puede hacer de muchas formas, y va a depender de la intención.
Para el efecto, podemos usar los métodos del objeto handle.
El método read( ) lee grupos de caracteres, incluso el archivo completo.
El método readline( ) lee una línea completa incluido el salto de linea.
EL método readlines( ) lee todo el archivo, dejando cada línea en una posición de una lista.
Cargar todo el archivo en memoria puede ser riesgoso, pues se debe estar seguro de que la memoria es suficiente. Es recomendable conocer con antelación las proporciones de los archivos que desea leer completamente en memoria, para no incurrir en errores de carga, o penalizaciones de los procesos.
De otro lado, y si quiero leer línea a línea, el archivo deberá contar con saltos de línea: caracter 10 (\n) en sistemas Unix y Linux, o caracter 10 y 13(\n\r) en Windows.
[1] Una función ‘helper’ es una función de librería que apoya la ejecución de otras funciones. La librería __builtins__ de Python contiene funciones que llaman métodos de otros objetos, para facilitar la escritura del código. Esta librería se carga siempre de forma automática, y las funciones ‘helper’ pueden ser invocadas sin necesidad de referirse a un objeto concreto.
EJEMPLO: TOTAL INFECTADOS SARS-COV-2 POR CONTINENTE
Construya una función Python que lea el archivo the complete Our World in Data COVID-19 dataset("Coronavirus Source Data", 2020), y devuelva un diccionario Python donde las claves son los nombres de los continentes, y los valores para cada clave son el total de muertes a la fecha para cada continente. Los campos del registro están delimitados por el caracter coma: a este tipo de delimitación se le conoce como CSV (Coma Separated Vales). El primer registro es informativo, y corresponde a los nombres de los campos: iso_code , continent , location , date , total_cases , new_cases , total_deaths , new_deaths,… A continuación se muestra parcialmente un registro: “GBR,Europe,United Kingdom,2020-03-17,1543.0,152.0,65.0,22.0,22.729,2.239,…” Tenga en cuenta: Los campos de interés para el problema son continent y total_deaths. Registros que no tengan dato en el campo iso_code no deben ser procesados. Registros cuyo iso_code es OWID_WRL no deben ser procesados. R/ import os # #función que totaliza el número de muertes por continente # def covid_19_deaths_by_contient(file): deaths, ISO_CODE, CONTINENT, DEATHS = 0, 0, 1, 7 stats = { } assert os.path.isfile(file) , "archivo no existe" data = open(file,"r") #abrir archivo modo lectura data.readline() #descartar fila de encabezados for rec in data: #recorrer registros campos = rec.split(",") #extraer campos continent = campos[CONTINENT] #extraer continente deaths = campos[DEATHS] #extraer muertes país if campos[ISO_CODE] in [ 'OWID_WRL' , '']: #evitar ciertos códigos continue if campos[CONTINENT] == '': #evitar continente vacío continue if not continent in stats: #si continente no en colección, adicionarlo con valor 0 stats[continent] = 0 try: #sumar las muertes al continente stats[continent] += float(deaths) except ValueError: #controlar conversión continue data.close() return stats if __name__ == "__main__": result = covid_19_deaths_by_contient("owid-covid-data.csv") print(result) |
SESIÓN #8 DE EJERCITACIÓN: ARCHIVOS
- La hormiga Maria Bitolia de Bitlandia II.
Repita el problema (La hormiga Maria Bitolia de Bitlandia sobre cadenas de texto) para determinar el tiempo que toma en recorrer Malia Bitolia un texto, pero esta vez con la lectura de los caracteres desde un archivo de texto. La entrada es el nombre del archivo de texto, y la salida del algoritmo Python será el tiempo en segundos, minutos, horas, y días que toma en recorrer el archivo. El problema lo puede localizar en este libro buscando por el título “La hormiga Maria Bitolia de Bitlandia” - La hormiga Maria Bitolia de Bitlandia III.
Repita el problema anterior, esta vez considerando que se entrega una lista de archivos que recorrerá Malia Bitolia. El algoritmo deberá emitir el tiempo que toma Malia Bitolia patinando cada uno de los archivos, en segundos, minutos, horas y días. - Distribución cifras de pi.
La URL https://www.angio.net/pi/digits/pi1000000.txt permite descargar un archivo con un millón de cifras de la constante pi.
Construya una función Python que emita una estadística sobre el porcentaje que cada dígito del 0 al 9 se encuentra en ese archivo. - Secuencia más larga de dígitos repetidos en el número pi.
La URL https://www.angio.net/pi/digits/pi1000000.txt permite descargar un archivo con un millón de cifras de la constante pi.
Construya una función Python que permita determinar cuál es la secuencia de dígitos repetidos más larga que hay en ese primer millón de cifras decimales de pi. - palíndromo más largo de dígitos repetidos en el número pi.
La URL https://www.angio.net/pi/digits/pi1000000.txt permite descargar un archivo con un millón de cifras de la constante pi.
Construya una función Python que permita determinar cuál es la secuencia de dígitos palíndroma más larga que hay en ese primer millón de cifras decimales de pi. - Contar genes en archivo Fasta. [BIO]
Un archivo Fasta, es un archivo con secuencias del genoma de un organismo. Las secuencias pueden ser de nucleótidos que representan un genoma, o de aminoácidos, que representan proteínas. Un ejemplo de un fragmento de un archivo fasta se presenta a continuación:
>WP_011405638.1 MULTISPECIES: 5'/3'-nucleotidase SurE [Methanosphaera] MNILITNDDGLTSNGIIAARNSVEDLGQTTLVAPLTQQSGVGHAITLMKPLRAIKTELSDKTYGYAVTGTPTDCVILAVK
SIMDKKPDLIISGMNIGENLSRSITTSGTLGATFEAASFGIPAIAVSLQVNREDLKFRTGVNFIDYSHAESIVNKLAKKV
IKHGMPEGVDILNLNIPANPDSDEIIQSNFADRMFSTDVEKRIDPYGHPYYWIVGDLIDDGIEGTDVHTLHILNQPAVTP
ISIDMDAQVNISKWLD
>WP_011405639.1 MULTISPECIES: methanogenesis 12 protein [Methanosphaera]
MKYYMGMDHGTTAISFEIIDENKEEVSYFKLNRDKLSKKEIFFKDIINDKIDIKKVKLLAMTYAMGDGISKITPIDLVKD
RGIQSINGAGKVTGGGTTVYEDIMELNIPSVLIPGLHSGCEFLDDRFRASYSHCGSPEKVSLSYYAYLKTGFKNMIIADI
SSNTVCILVEDGKIKGAMDACVGAMGFIHGPLDLDMIRDIDSGKKTANEAFSHAGISKIACVDSQINNVKDDILEKALHN
DKKGLLAIRSLVMSVIMEIYGLYGIMENKIDGIVLTGSGGCMTSPINISGMIKEKIERICPVYVLGSDSGAIGSSYIAYD
IEKNKVDKIMGIDVIYE
Cada registro representa un gen. Los registros comienzan con un signo >. La fila del signo > es la cabecera de un registro y es informativa. Luego de la línea de cabecera, vienen varias líneas separadas por salto (caracter ascii 10) que representan la secuencia del gen.
Construya una función Python que determine cuántos genes contiene un archivo Fasta. Para pruebas, puede descargar un archivo fasta desde el sitio web https://www.ncbi.nlm.nih.gov - Palabra más larga de un libro.
Construya una función Python que reciba el nombre de un archivo de texto, y determine cuál es la palabra más larga utilizada por el autor.
Use la base de datos de libros Gutemberg (https://www.gutenberg.org), y descargue un libro de su preferencia en formato de texto para hacer el análisis. - Palabras palíndromas en un libro I.
Construya una función Python que reciba el nombre de un archivo de texto y una longitud de palabra mínima, y determine cuántas palabras palíndromas hay en el archivo manteniendo la restricción de longitud mínima. Una palabra palíndroma es aquella que se lee igual en cualquier sentido.
Use la base de datos de libros Gutemberg (https://www.gutenberg.org), y descargue un libro de su preferencia en formato de texto para hacer el análisis.
Palabras palíndromas en un libro II.
Construya una función Python que reciba el nombre de un archivo de texto y una longitud de palabra mínima, y emita una lista de palabras palíndromas y su respectiva frecuencia en el texto. Una palabra palíndroma es aquella que se lee igual en cualquier sentido.
Use la base de datos de libros Gutemberg (https://www.gutenberg.org), y descargue un libro de su preferencia en formato de texto para hacer el análisis. - Methanosphaera stadtmaniae I. [BIO]
Methanosphaera stadtmaniae es una archaea metanógena no motil, gram-positivo, de forma esférica que obtiene energía usando hidrógeno para reducir metanol a metano. Es parte de la biota del intestino largo humano. La secuencia de la archaea se encuentra disponible en NCBI bajo la referencia MGYG-HGUT-02164.
Construya una función Python que devuelva una lista Python con los códigos de proteína dependientes de nickel. Esta información está en el encabezado de cada proteína. Simplemente busque la palabra “nickel” en el encabezado. - Methanosphaera stadtmaniae II. [BIO]
Methanosphaera stadtmaniae es una archaea metanógena no motil, gram-positivo, de forma esférica que obtiene energía usando hidrógeno para reducir metanol a metano. Es parte de la biota del intestino largo humano. La secuencia de proteínas de la archaea se encuentra disponible en NCBI bajo la referencia MGYG-HGUT-02164.
Construya una función Python que devuelva el encabezado de proteína con la mayor presencia relativa de histidina (‘H’). La presencia relativa es el conteo de histidinas, dividido el número de aminoácidos dentro de la proteína. - Methanosphaera stadtmaniae III. [BIO]
Methanosphaera stadtmaniae es una archaea metanógena no motil, grampositivo, de forma esférica que obtiene energía usando hidrógeno para reducir metanol a metano. Es parte de la biota del intestino largo humano. La secuencia de proteínas de la archaea se encuentra disponible en NCBI bajo la referencia MGYG-HGUT-02164.
Construya una función Python que devuelva el código de la proteína de mayor peso molecular. El peso molecular en gramos por mole de una proteína se halla sumando los pesos moleculares individuales de los aminoácidos de la proteína. Use termofisher para los pesos moleculares en gramos de los aminoácidos (https://www.thermofisher.com/co/en/home/references/ambion-tech-support/rna-tools-and-calculators/proteins-and-amino-acids.html) - Palabra que más se usó en un libro.
Construya una función Python que reciba el nombre de un archivo de texto y una longitud de palabra mínima, y determine cuál es la palabra que más se usa en el archivo manteniendo una restricción de longitud mínima dada como parámetro.
Use la base de datos de libros Gutemberg (https://www.gutenberg.org), y descargue un libro de su preferencia en formato de texto para hacer el análisis.
Cuál es la palabra de más de 5 letras que más se usa en ‘Don Quijote’?
Determine cuál es la palabra de más de 6 letras que más se usa en la novela‘Varney The Vampire Or The Feast Of Blood’, disponible en https://gutenberg.org/cache/epub/14833/pg14833.txt. - Estadística de letras en un libro.
Construya una función Python que reciba el nombre de un archivo de texto, y emita una tabla con la frecuencia de las letras en todo el texto.
Use la base de datos de libros Gutemberg (https://www.gutenberg.org), y descargue un libro de su preferencia en formato de texto para hacer el análisis. - Proteína más larga de un microorganismo. [BIO]
Construya un programa Python que permita determinar cuál es la proteína más larga de un archivo en formato CSD Fasta .faa. Puede descargar archivos con este formato desde los repositorios NCBI.
El programa deberá funcionar como un programa de línea de comando, al cual se le pase como argumento el nombre del archivo. Se imprime el encabezado de la proteína más larga dentro del archivo. - Estadística de palabras en un libro.
Construya una función Python que reciba el nombre de un archivo de texto y una longitud de palabra mínima, y determine el top 10 de las palabras más usadas, manteniendo la restricción de longitud mínima.
Use la base de datos de libros Gutemberg (https://www.gutenberg.org), y descargue un libro de su preferencia en formato de texto para hacer el análisis. - Translated CDS. [BIO]
Una importante etapa en el análisis de información genética, es descifrar la secuencia de proteínas de cada gen. CDS es la secuencia de nucleótidos que corresponde con la secuencia de aminoácidos en una proteina.
Descargue el genoma completo del microorganism Hungateiclostridium clariflavum DSM 19732 (firmicutes) en formato CSD Fasta .fna, y en formato CSD Fasta .faa.
Revise las diferencias entre los dos archivos. Como se puede observar, el archivo .fna representan la secuencia de nucleótidos que corresponden con la secuencia de amino ácidos en una proteína.
El archivo faa es la equivalencia proteica del archivo fna de nucleótidos. Se presenta a continuación un ejemplo de la primera entrada de ambos archivos CSD del microorganismo, Hungateiclostridium clariflavum.
--fna file--
>lcl|NC_016627.1_cds_WP_014253399.1_1 [gene=dnaA] [locus_tag=CLOCL_RS00005] [protein=chromosomal replication initiator protein DnaA] [protein_id=WP_014253399.1] [location=567..1901] [gbkey=CDS]
ATGAGTGCTCAATTATCCGAAATATGGCAGAAAACTTTAGGCCTTTTACAAAACGAGTTAACCGAAATAAGTTTTAATAC
TTGGATTAAAACCATTGAGCCGATTTCCATACAAAATAATACTATTAATCTGGCCGTTCCTGCCGAATTTAACAAAGGCA
TTTTAGAATCAAGATATCAATCTCTTATAAAGAATGCTATCAAACATGTTACATACAAGGAATATTCAA… - --fna file--
>lcl|NC_016627.1_prot_WP_014253399.1_1 [gene=dnaA] [locus_tag=CLOCL_RS00005] [protein=chromosomal replication initiator protein DnaA] [protein_id=WP_014253399.1] [location=567..1901] [gbkey=CDS]
MSAQLSEIWQKTLGLLQNELTEISFNTWIKTIEPISIQNNTINLAVPAEFNKGILESRYQSLIKNAIKHVTYKEYSINFV
VPSQENIEKYKNTTDSTFNEDPSTTMLNPKYTFDTFVIGNSNRFAHAAALAV…
Construya una función python que haga la transcripción del archivo CDS faa dado como entrada, hacia un archivo faa de salida. - Accidentes de tránsito con motos en Medellín, Colombia.
Los accidentes de tránsito con motos registrados por la Secretaría de Movilidad de la Alcaldía de Medellín, pueden ser descargados desde el sitio web https://www.datos.gov.co/Estad-sticas-Nacionales/Accidentalidad-con-motos-municipio-de-Medell-n-act/b7ik-2upt. Se entiende por accidente de tránsito: "evento, generalmente involuntario, generado al menos por un vehículo en movimiento, que causa daños a personas y bienes involucrados en él, e igualmente afecta la normal circulación de los vehículos que se movilizan por la vía o vías comprendidas en el lugar o dentro de la zona de influencia del hecho". (Ley 769 de 2002 - Código Nacional de Tránsito).
Descargue el archivo en formato CSV.
Construya una función Python que determine lo siguiente:
- Año de mayor accidentalidad.
- Rango horario de mayor accidentalidad (asuma un rango de 2 horas: 0-2,2-4,4-6,… 18-20,20-22,22-24)
- Total de accidentes, agrupado por gravedad.
- Total de accidentes, agrupado por accidente.
- Total de accidentes, agrupado por diseño vial.
- Lista ordenada por zona, de mayor a menor accidentalidad.
- Estructure una matriz de salida que le permita revisar alguna de las variables por año y por variable. La variable se representa en las columnas, y los años en las filas. - Estadísticas accidentes de tránsito.
Los accidentes de tránsito con motos registrados por la Secretaría de Movilidad de la Alcaldía de Medellín, pueden ser descargados desde el sitio web https://www.datos.gov.co/Estad-sticas-Nacionales/Accidentalidad-con-motos-municipio-de-Medell-n-act/b7ik-2upt. Se entiende por accidente de tránsito: "evento, generalmente involuntario, generado al menos por un vehículo en movimiento, que causa daños a personas y bienes involucrados en él, e igualmente afecta la normal circulación de los vehículos que se movilizan por la vía o vías comprendidas en el lugar o dentro de la zona de influencia del hecho". (Ley 769 de 2002 - Código Nacional de Tránsito).
Descargue el archivo en formato CVS, y aplique las siguientes estadísticas:
-'Skewness' y la 'Skewness' estandarizada
-Kurtosis y kurtosis estandarizada
Se presenta abajo las fórmulas que se requieren