Un lenguaje de programación es un lenguaje formal que proporciona una serie de instrucciones que permiten a un programador escribir secuencias de órdenes y algoritmos a modo de controlar el comportamiento físico y lógico de una computadora con el objetivo de que produzca diversas clases de datos.

El nombre del lenguaje Python proviene del popular programa de Monty Python grupo británico de seis humoristas que sintetizó en clave de humor la idiosincrasia británica de los años 1960 y 1970.

Desarrollado inicialmente por un programador holandés llamado Guido van Rossum a fines de la década de 1980 pero aparece en 1991.


Python es un lenguaje de programación moderno de:

• Propósito general.
• Interpretado, dinámico y multiplataforma..
• Multiparadigma. Ya que soporta parcialmente la orientación a objetos, programación imperativa y, en menor medida, programación funcional.
• Posee una licencia de código abierto, denominada Python Software Foundation License
• Programación Imperativa. Se describe en términos de instrucciones, condiciones y pasos que modifican el estado de un programa al permitir la mutación de variables, todo esto con el objetivo de llegar a un resultado.
• Funcional. Es un paradigma de programación declarativa basado en el uso de verdaderas funciones matemáticas.
• Reflexivo. Es la capacidad que tiene un programa para observar y opcionalmente modificar su estructura de alto nivel. En un sentido más amplio, la reflexión es una actividad computacional que razona sobre su propia computación. Se preserva la estructura como metadatos en el código generado. Dependiendo de la implementación, el código con reflexión tiende a ser más lento que el que no lo tiene.

Compilación

El programa fuente se traduce una vez obteniendo un archivo que contiene el código de la máquina; el programa que realiza esta traducción se llama compilador o traductor.

Interpretación

Cualquier usuario del código puede traducir el programa fuente cada vez que se ejecute; el programa que realiza este tipo de transformación se denomina intérprete, ya que interpreta el código cada vez que está destinado a ejecutarse; también significa que no puede distribuir el código fuente tal como está, porque el usuario final también necesita que el intérprete lo ejecute.

Un programa de computadora es en realidad una pieza de texto, por lo que el código fuente generalmente se coloca en archivos de texto.

El intérprete lee el código fuente y verifica si todas las líneas subsiguientes son correctas.

Si el compilador encuentra un error, termina su trabajo inmediatamente. El único resultado en este caso es un mensaje de error. El intérprete le informará dónde se encuentra el error y qué lo causó.

También es posible que una parte significativa del código se ejecute con éxito antes de que el intérprete encuentre un error. Este es el comportamiento normal en este modelo de ejecución.

Si deseas programar en Python, necesitarás el intérprete de Python.

Python es un lenguaje de programación de alto nivel, interpretado, orientado a objetos y de uso generalizado con semántica dinámica, que se utiliza para la programación de propósito general.

En 1999, Guido van Rossum definió sus objetivos para Python:

• Un lenguaje fácil e intuitivo tan poderoso como los de los principales competidores.
• De código abierto, para que cualquiera pueda contribuir a su desarrollo.
• El código que es tan comprensible como el inglés simple.
• Adecuado para tareas cotidianas, permitiendo tiempos de desarrollo cortos.

Posibles usos:

• Desarrollo web
• Ciencia de datos y aprendizaje automático
  • Su sintaxis simple permite que las personas que no tienen experiencia en programación lo utilicen para el procesamiento de datos y el entrenamiento de modelos sin perder mucho tiempo aprendiendo un nuevo idioma.
  • Python admite una gran cantidad de bibliotecas de terceros para aprendizaje automático, redes neuronales, estadísticas y cálculos numéricos, lo que facilita mucho su trabajo.
  • Con Python, es posible recopilar, limpiar y explorar datos, así como entrenar modelos y visualizar los resultados, ¡todo en una sola configuración!
  • La comunidad de desarrolladores de Python ML es muy grande, por lo que siempre puede encontrar soporte para sus tareas.
• Scripting. Automatización de tareas, como procesamiento de texto o simulación de acciones típicas del usuario
• Con menos frecuencia: desarrollo de escritorio

Lanzamientos:

• Python 1.0 fue lanzado en 1994
• Python 2.0 fue lanzado en 2000
• Python 3.0 fue lanzado en 2008

print("Learn Python to be great!")

Python es un lenguaje de programación que te permite trabajar rápidamente e integrar sistemas de forma más eficaz.

Python es un lenguaje de programación orientado a objetos claro y poderoso, comparable a Perl, Ruby, Scheme o Java.

Python es un lenguaje de programación interpretado cuya filosofía hace hincapié en la legibilidad de su código.​

Se trata de un lenguaje de programación multiparadigma, ya que soporta parcialmente la orientación a objetos, programación imperativa y, en menor medida, programación funcional.

• Para instalar Python acceda a Python.org y en la sección de descargas obtenga la versión deseada.
• Ejecute el instalador de Python

Ir a Distribución en Windows

Distribución de Python en la Microsoft Store



Así se muestra la terminal de la Distribución de Python en la Microsoft Store



Para Visual Studio Code se puede configurar de la siguiente manera:



Puede usar la siguiente extensión: ms-python.pyhton



python -m pip install --upgrade pip
python -m pip install -U pip
python -m pip install -U matplotlib

Verifique o agregue al path la ubicación del ejecutable de Python:

- Panel de control\Sistema y seguridad\Sistema > Configuración avanzada del sistema
- Propiedades del sistema > Variables de entorno > Variables del sistema > Path > Editar C:\PythonXX

- Abra una ventana de símbolo del sistema o CMD
- Puede ingresar:

• python --version y [enter]
• python3 --version y [enter] para comprobar sobre la versión 3 especificamente

- Si ya esta instalado Python, entonres ingrese python y [enter]
- Esto hará que acceda al entorno de Python o shell
- Indicando la versión de Python instalada
- A continuación se presenta el prompt en espera de comandos de Python


NOTA: la versión 2.7 su mantenimiento ha llegado a su end-of-life.

Para salir del entorno de Python ingrese:

Puede ser de utilidad un: Compilador en línea de Python

- En el entorno de Python escriba:

>>>print("Hola Mundo") y [enter]

- print es una función que sirve para desplegar mensajes al usuario.

El uso de comillas simples y dobles es valido, la regla es que unas estén contenidas en las otras (y viceversa).

Las siguientes instrucciones son validas:

print("'Hola mundo'") print('"Hola mundo"')

Es posible escribir cadenas de varias líneas en Python, para hacer eso, debe usar comillas triples en cada lado del literal de cadena.

print("""Las triples comillas para varias líneas""")

También se pueden usar las comillas simples '''

El sangrado se utiliza para delimitar la estructura del programa permitiendo establecer bloques de código.

Es muy importante para la correcta ejecución del código.

Python usa la indentación para establecer el ámbito (scope), a diferencia de otros programas que usan { } para ello.

Los archivos de Python tienen la extensión .py

- Cree un archivo con la extensión .py
- En el contenido del archivo escriba print("Hola Mundo")
- Asegurese de estar en el directorio que contiene el archivo creado .py
- Ingrese el nombre del archivo y [enter]

Nota: o desde donde se encuentre indique la ruta y nombre del archivo a ejecutar.

Otras extensiones validas de Python son: .py, .pyc, .pyd, .pyo, .pyw, .pyz, .pyi

Un comentario sirve para cualquier tipo de anotación que deseamos hacer en el código, pero que no debe formar parte del código a interpretar como parte de la ejecución del programa.

La sintaxis de Python para los comentarios se realiza escribiendo el símbolo # (almohadilla​ o el numeral​ o cardinal o signo de número)

Todo lo que este escrito despues del símbolo # será ignorado por Python.

A veces es necesario explicar para qué sirven algunas partes particulares del código.

Python brinda la oportunidad de satisfacer esas necesidades, puede dejar notas especiales llamadas comentarios. Son especialmente útiles para principiantes.

Se llama comentario en línea ( inline comment ) porque está escrito en la misma línea que el código.

print("This will run.") # This won't run

Comentarios de acuerdo con las mejores prácticas

Después de una marca de almohadilla # debe haber un espacio y, en los comentarios en línea, debe haber dos espacios entre el final del código y la marca de almohadilla.

También es aceptable poner más de dos espacios entre el final del código y la marca de almohadilla, pero lo más común es que haya exactamente dos espacios.

Aplica una sangría a tu comentario al mismo nivel que la declaración que explicar

Un comentario no debería ser demasiado largo, la guía PEP-8 indica que la longitud del comentario debe limitarse a 72 caracteres.

Es mejor dividir un comentario largo en varias líneas: puede hacerlo agregando una marca de almohadilla al comienzo de cada nueva línea

Los comentarios que abarcan varias líneas se denominan multi-line o de bloque.

Comentarios para Documentación

Puede encontrar comentarios de varias líneas entre comillas triples "" "..." "".

Las comillas triples están reservadas para cadenas de documentación. También son informativos, pero su uso se limita a funciones, métodos y varios otros casos.

https://docs.python.org/3/tutorial/datastructures.html

Cada objeto de datos como una variable o una constante tiene un tipo que describe cómo mantenerlo en la memoria, qué operaciones se pueden aplicar a este objeto y cómo calcularlas.

Es el valor mismo. Un literal se refiere a datos cuyos valores están determinados por el literal mismo.

But a literal is not a name -- it is the value itself.

Literales son notaciones para representar valores fijos en el código.

Existe un literal especial más utilizado en Python: el literal None. Este literal es llamado un objeto de NonType (ningún tipo), y puede ser utilizado para representar la ausencia de un valor.

Cuando los datos y operadores se unen, forman juntos expresiones. La expresión más sencilla es el literal.

La variable es un lugar con nombre donde puede almacenar algún valor y acceder al valor más tarde.

Par nombre-valor, donde su valor no puede cambiar, permanece fijo durante toda la ejecución del programa.

Nombre será aquel que designemos para identificar a un valor cambiante.

Par nombre-valor, donde su valor si puede cambiar durante la ejecución del programa.

Una variable puede ser declarada con ámbito global anteponiendo global en su declaración

Una variable se crea cuando se le asigna un valor. A diferencia de otros lenguajes de programación, no es necesario declararla.

Si se le asigna cualquier valor a una variable no existente, la variable será automáticamente creada. No se necesita hacer algo más.

Para eliminar la definición de una variable use la instrucción del

PEP 8, un espacio antes y después del signo de asignación (=) se considera una buena práctica.

Utilice minúsculas y guiones bajos para dividir palabras. Si desea definir una constante, es común escribir su nombre en mayúsculas y, nuevamente, separar las palabras con guiones bajos. Normalmente, las constantes se almacenan en archivos especiales llamados módulos.

Evite los nombres de una letra que podrían confundirse fácilmente con números como las letras: 'l' 'O/o', 'I'.

Aunque puede utilizar cualquier símbolo Unicode, la convención de estilo de código recomienda limitar los nombres de variable con caracteres ASCII.

Si el nombre de variable más adecuado es alguna palabra clave de Python, agregue un guión bajo al final.

Elija un nombre que tenga sentido. El nombre de la variable debe ser legible y descriptivo y debe explicar al lector qué tipo de valores se almacenarán en él.

No uses nombres demasiado genéricos. Intente elegir un nombre que explique el significado de la variable, de 1 a 3 palabras suelen ser suficientes.

Si una palabra es larga, intente encontrar la forma corta más común y esperada.

Evite los nombres de la lista de tipos built-in (incorporada).

Todas las convenciones de nomenclatura y las mejores prácticas son opcionales, pero se recomienda encarecidamente seguirlas, ya que hacen que su código sea más legible y autodescriptivo para usted y otros programadores.

Cada variable tiene un nombre específico que la distingue de otras variables. Existen algunas reglas para nombrar variables que debe seguir:

• Los nombres distinguen entre mayúsculas y minúsculas ("fecha" no es lo mismo que "Fecha");
• Un nombre comienza con una letra o un guión bajo, seguido de letras, dígitos y guiones bajos (por ejemplo, nombre de usuario, puntuación1, _cuenta);
• Un nombre no puede comenzar con un dígito (por ejemplo, 2q no es un nombre válido);
• Un nombre no debe ser una palabra clave (keyword palabra reservada).

Cada variable tiene un nombre que la identifica de forma única entre otras variables.

Dar un buen nombre a una variable puede no ser tan simple como parece.

Los programadores experimentados son cuidadosos al nombrar sus variables para asegurarse de que sus programas sean fáciles de entender.

Es importante porque los programadores pasan mucho tiempo leyendo y entendiendo el código escrito por otros programadores.

Si las variables tienen nombres incorrectos, incluso su propio código le parecerá confuso de leer en unos meses.

Siempre que usa un signo igual =, en realidad asigna algún valor a un nombre. Por esa razón, al signo de = se le suele denominar operador de asignación.

Operadores de asignación compuesta

Hay otros operadores de asignación que puede usar en Python, se denominan operadores de asignación compuesta, ya que realizan una operación aritmética y una asignación en un solo paso:

+=, -=, *=, /=, %=, **=, //= .

Operadores lógicos

Otro tipo son los operadores lógicos:

&, |, ^, ~, <<, >>, In, Not in, Is, Is not,

Operadores comparación

Las operaciones de comparación o relación le permiten comparar dos valores y determinar la relación entre ellos.

Hay diez operadores de comparación en Python:

1. < menor que
2. <= menor que o igual
3. > mayor que
4. >= mayor que o igual
5. == igual
6. != no igual
7. is
8. is not
9. in esta en
10. not is no esta en

El resultado de aplicar estos operadores siempre es bool.

Operadores aritméticos

Un signo de ** (doble asterisco) es un operador de potencia (exponenciación).

El argumento a la izquierda es la base, el de la derecha, el exponente.

Cuando ambos ** argumentos son enteros, el resultado es entero también.

Cuando al menos un ** argumento es flotante, el resultado también es flotante.

Un símbolo de * (asterisco) es un operador de multiplicación.

Un símbolo de / (diagonal) es un operador de división.

El valor después de la diagonal es el dividendo, el valor antes de la diagonal es el divisor.

Hay una excepción a la regla, el resultado producido por el operador de división siempre es flotante,

Un símbolo de // (doble diagonal) es un operador de división entera.

El resultado carece de la parte fraccionaria, está ausente (para los enteros), o siempre es igual a cero (para los flotantes); esto significa que los resultados siempre son redondeados. Se ajusta a la regla entero vs flotante. El redondeo siempre va hacia abajo. La division entera también se le suele llamar en inglés floor division.

Módulo / es el residuo que queda de la división entera, es el valor que sobra después de dividir un valor entre otro para producir un resultado entero.

La división entre cero no funciona.

No se debe intentar, dividir entre cero, realizar una división entera entre cero o encontrar el residuo de una división entre cero.

Se pueden emplear tantos paréntesis como se necesiten, y seguido son utilizados para mejorar la legibilidad de una expresión, aun si no cambian el orden de las operaciones.

Una expresión es una combinación de valores (o variables, operadores, llamadas a funciones, aprenderás de ello pronto) las cuales son evaluadas y dan como resultado un valor

Los operadores son símbolos especiales o palabras clave que son capaces de operar en los valores y realizar operaciones matemáticas

Un operador unario es un operador con solo un operando.

Un operador binario es un operador con dos operados

Algunos operadores actúan antes que otros, a esto se le llama jerarquía de prioridades.

Los números enteros se pueden usar para contar cosas en el mundo real, mientras que los números de punto flotante son una buena opción para cálculos estadísticos y científicos.

Los sistemas de numeración Octales y Hexadecimales son similares pues emplean 8 y 16 como sus bases respectivamente. El sistema hexadecimal utiliza los números decimales más seis letras adicionales.

Nota: octal 0o... hexadecimal 0x...

Para aquellos valores sin un componente fraccionario.

int (enteros con signo). Llamados enteros o ints, son números enteros (positivo, negativo o cero), sin punto decimal.

El uso de guion bajo es permitido en los literales numéricos:

11_111.11

Se refiere a números decimales

float (Números de punto flotante). Llamados flotantes, representan números reales y tienen un punto decimal.

La letra E (también se puede utilizar la letra minúscula e - proviene de la palabra exponente) la cual significa por diez a la n potencia.

3E8

El exponente (el valor después de la E) debe ser un valor entero.

La base (el valor antes de la E) puede o no ser un valor entero.

Secuencia de caracteres.

Las cadenas de Python son secuencias, no son listas, pero pueden ser tratadas como tal.

El truco de las comillas simples y dobles para su combinación

Como sabemos para representar un conjunto (cadena) de caracteres en la sintaxis de Python permite el uso de comillas simples o dobles.

La sintaxis es la regla el lenguaje define para escribir código y que sea considerado como correcto, pero ¿Cuál es tu estilo? o cual es tu costumbre al escribir ¿Comilla simple o doble?.

El truco para su combinación es otra regla, unas debes estar contenidas en otras, recuerda que van por pares, comilla al inicio y comilla al final del string.

Si tienes que escribir código sin combinaciones de comillas puedes usar el carácter de escape \

print("90's") print('"Monty Python"') print(len('90\'s')) # 4 print("\"Monty Python\"")

Las cadenas de Python son inmutables. Con las listas podemos usar del para eliminar un elemento. No se puede eliminar un caracter de una cadena, sin embargo al aplicar del a la cadena esta es eliminada por completo. Tampoco se puede usar el método append() para expander una cadena.

Lo que se estila al manipular cadenas es sobreescribirlas.

saludo = "H" saludo += "o" saludo += "l" saludo += "a" saludo += "!" print(saludo)

Iterar una cadena

for c in "Python": print(c, end='-')

Slice:

lp = "Python" print(lp[:]) # Python print(lp[1:]) # ython print(lp[:1]) # P print(lp[:2]) # Py print(lp[:3]) # Pyt print(lp[:4]) # Pyth print(lp[-1:]) # n print(lp[-2:]) # on print(lp[-3:]) # hon print(lp[-4:]) # thon

Siempre que desee trabajar con algún tipo de información textual en su programa, tendrá que trabajar con cadenas.

El tipo de cadena se llama str.

Los literales de cadena se pueden delimitar mediante comillas simples o dobles.

Concatenación. Combinación de secuencia de caracteres (strings)
>>> a = "Hola"
>>> b = "Mundo"
>>> print(a + " " + b)
Hola Mundo

Se puede utilizar print() para combinar texto con variables utilizando el operador + para mostrar cadenas con variables

El signo de * (asterisco), cuando es aplicado a una cadena y a un número (o a un número y cadena) se convierte en un operador de replicación.

¿Podemos multiplicar strings?, veamos...

>>> c = a + " " + b
>>> print(c*3)
Hola MundoHola MundoHola Mundo

Un número menor o igual que cero produce una cadena vacía.

En general, las cadenas pueden ser: concatenadas (unidas) + y replicadas *.

La capacidad de usar el mismo operador en tipos de datos completamente diferentes (como números o cadenas) se llama overloading - sobrecarga (debido a que el operador está sobrecargado con diferentes tareas).

El operador + es empleado en dos o más cadenas y produce una nueva cadena que contiene todos los caracteres de sus argumentos

El operador * necesita una cadena y un número como argumentos; en este caso, el orden no importa: puedes poner el número antes de la cadena, o viceversa, el resultado será el mismo: una nueva cadena creada por la enésima replicación de la cadena del argumento.

in, not in

Los operadores in y not in pueden ser aplicados a cadenas

print("y" in "Python") # True print("j" in "Python") # False

La función ord()

Dada una cadena que representa un carácter Unicode, devuelve un número entero que representa el punto de código Unicode de ese carácter.

print(ord("@")) # 64

La función necesita una cadena de un caracter como argumento - incumplir este requisito provoca una excepción TypeError

La función chr()

Devuelve la cadena que representa un carácter cuyo punto de código Unicode es el entero i.

print(chr(193)) # Á

Invocándolo con un argumento inválido (por ejemplo, un punto de código negativo o inválido) provoca las excepciones ValueError o TypeError

min() y max()

¿Se puede aplicar la función min() y max() a una cadena?.

Si, para determinar el caractér cuyo punto de código Unicode entero es el menor o mayor.

print(min("aeiou"), ord(min("aeiou"))) # a 97 print(max("aeiou"), ord(max("aeiou"))) # u 117

String Methods

str.index(sub[, start[, end]])

python.org/3/library/stdtypes.html#string-methods

Las cadenas tienen varios métodos para su manipulación. El método index() devuelve el índice correspondiente de un carácter en la cadena

print("Python".index("P")) # 0 print("Python".index("y")) # 1 print("Python".index("t")) # 2 print("Python".index("h")) # 3 print("Python".index("o")) # 4 print("Python".index("n")) # 5

Si index() no encuentra el carácter que se pasa como argumento, genera una excepción ValueError

try: print("Python".index("!")) # ValueError: substring not found except ValueError: print("substring not found")

str.count(sub[, start[, end]])

Devuelve el número de apariciones no superpuestas de subcadena sub en el rango [inicio, fin]. Los argumentos opcionales start y end se interpretan como en notación de sector.

print("Hello".count("l")) # 2

str.capitalize()

Devuelve una copia de la cadena con su primer carácter en mayúsculas y el resto en minúsculas.

print("ángeles".capitalize()) # Ángeles

str.center(width[, fillchar])

Retorno centrado en una cadena de largo y width. El relleno se realiza utilizando el fillchar especificado (el valor predeterminado es un espacio ASCII).

Se devuelve la cadena original si el width es menor o igual que len(s).

print('*' + 'Python'.center(12) + '*') # * Python *

print('#' + 'Python'.center(12,"-") + '#') # #---Python---#

str.endswith(suffix[, start[, end]])

Devuelve True si la cadena termina con el suffix especificado; de lo contrario, devuelve False.

suffix también puede ser una tupla de sufijos a buscar. Con inicio start, pruebe comenzando en esa posición.

Con el end opcional, deja de comparar en esa posición. print("Python".endswith("n")) # True

print("Python".endswith("P")) # False

str.find(sub[, start[, end]])

Devuelve el índice más bajo en la cadena donde la subcadena sub se encuentra dentro del segmento s[inicio: fin].

Los argumentos opcionales start y end se interpretan como en notación de sector. Devuelve -1 si no se encuentra sub.

print("Python".find("h")) # 3

print("Python".find("J")) # -1 (no se encuentra)

Podríamos encontrar las coincidencias en un texto de una subcadena:

txt = "Built-in Functions" sub = "i" fnd = txt.find(sub) while fnd != -1: print("'", sub, "' se encontro en la pos:", fnd) fnd = txt.find(sub, fnd + 1)

Salida:

' i ' se encontro en la pos: 2
' i ' se encontro en la pos: 6
' i ' se encontro en la pos: 14

str.isalnum()

Devuelve True si todos los caracteres de la cadena son alfanuméricos y hay al menos un carácter, False en caso contrario.

Un carácter c es alfanumérico si uno de los siguientes devuelve True:

c.isalpha (), c.isdecimal (), c.isdigit () o c.isnumeric ().

print(''.isalnum()) # False print('Python'.isalnum()) # True print('Python!'.isalnum()) # False

str.isalpha()

Devuelve True si todos los caracteres de la cadena son alfabéticos y hay al menos un carácter, False en caso contrario.

Los caracteres alfabéticos son aquellos definidos en la base de datos de caracteres Unicode como "Letra".

print("Python".isalpha()) # True print("Python!".isalpha()) # False

str.isdigit()

Devuelve True si todos los caracteres de la cadena son dígitos y hay al menos un carácter, False en caso contrario.

Los dígitos incluyen caracteres decimales y dígitos que necesitan un manejo especial, como los dígitos de superíndice de compatibilidad.

print("Python".isdigit()) # False print("3".isdigit()) # True

str.islower()

Devuelve True si todos los caracteres en mayúsculas en la cadena están en minúsculas y hay al menos un carácter en mayúsculas, de lo contrario es False.

print("Python".islower()) # False print("python".islower()) # True

str.lower()

Devuelve una copia de la cadena con todos los caracteres en mayúscula convertidos a minúsculas.

print("PYTHON 3.9.2".lower()) # python 3.9.2

str.isupper()

Devuelve True si todos los caracteres en mayúscula de la cadena están en mayúsculas y hay al menos un carácter en mayúsculas, de lo contrario es False.

print("python".isupper()) # False print("PYTHON".isupper()) # True

str.isspace()

Devuelve True si solo hay espacios en blanco en la cadena y hay al menos un carácter, False en caso contrario.

print(' \n '.isspace()) # True print(" ".isspace()) # True print(" x".isspace()) # False

str.join(iterable)

Devuelve una cadena que es la concatenación de las cadenas en iterable.

Se generará un TypeError si hay valores que no son cadenas en iterables, incluidos los objetos de bytes.

El separador entre elementos es la cadena que proporciona este método.

print("/".join(["AC", "DC"])) # AC/DC print("".join(["Py", "thon"])) # Python

str.lstrip([chars])

Devuelve una copia de la cadena sin los caracteres iniciales.

El argumento chars es una cadena que especifica el conjunto de caracteres que se eliminarán.

Si se omite o Ninguno, el argumento chars elimina los espacios en blanco de forma predeterminada.

El argumento chars no es un prefijo; más bien, todas las combinaciones de sus valores se eliminan

w = ' spacious *' print(w.lstrip()) # spacious * w = 'spacious ' print(w.lstrip()) # spacious w += "." print(w) # spacious . print('123-1234-12345'.lstrip('321-')) # 4-12345

str.replace(old, new[, count])

Devuelve una copia de la cadena con todas las apariciones de la subcadena antigua reemplazada por nueva. Si se proporciona el recuento de argumentos opcional, solo se reemplazan las primeras apariciones del recuento.

print("55*12*34*56*78".replace("*"," ")) # 55 12 34 56 78 print("55 12 34 56 78".replace(" ","-",2)) # 55-12-34 56 78

str.rsplit(sep=None, maxsplit=-1)

Devuelve una lista de las palabras de la cadena, utilizando sep como cadena delimitadora. Si se da maxsplit, como máximo se realizan divisiones de maxsplit, las más a la derecha. Si no se especifica sep o None, cualquier cadena de espacios en blanco es un separador.

print("P y t h o n".split()) # ['P', 'y', 't', 'h', 'o', 'n'] print("P.y.t.h.o.n".split(".")) # ['P', 'y', 't', 'h', 'o', 'n'] print("Hola mundo".split()) # ['Hola', 'mundo']

El tipo booleano, o simplemente bool, es un tipo de datos especial que solo tiene dos valores posibles: Verdadero y Falso.

En Python, los nombres de los valores booleanos comienzan con una letra MAYÚSCULA (True, False).

El tipo booleano o lógico es una forma común de representar algo que tiene solo dos estados opuestos como encendido o apagado, sí o no, etc.

atendido = False concluido = True omitido = False prendido = True vendido = False comprado = True pagado = False suspendido = True enviado = True terminado = False hecho = False cubierto = True devuelto = False impreso = True True > False True < False

Operaciones booleanas

Operadores booleanos integrados en Python: (not, and, or)

Los dos primeros son operadores binarios, lo que significa que esperan dos argumentos.

not es un operador unario, siempre se aplica a un solo operando.

1. not es un operador unario, invierte el valor booleano de su argumento.
   
   ser = True # ser es True
no_ser = not ser # no_ser es False


2. and es un operador binario, toma dos argumentos y devuelve True si ambos argumentos son verdaderos; de lo contrario, devuelve False.
   
   w = True and True # True
x = True and False # False
y = False and False # False
z = False and True # False



3. or es un operador binario, devuelve True si al menos un argumento es verdadero; de lo contrario, devuelve False.
   
   w = True or True # True
x = True or False # True
y = False or False # False
z = False or True # True


w and z devuelven w si w es Falso; de lo contrario, evalúa y devuelve z

w or z devuelve w si w es True; de lo contrario, evalúa y devuelve z

concluido = True atendido = False omitido = False prendido = True vendido = False pagado = False comprado = True w = concluido and prendido # True x = concluido and atendido # False y = omitido and vendido # False z = pagado and comprado # False print("\nOperador bi-nario: and") print(w) print(x) print(y) print(z) suspendido = True enviado = True terminado = False hecho = False cubierto = True devuelto = False dirigido = False impreso = True print("\nOperadores u-nario: or") w = suspendido or enviado # True x = cubierto or terminado # True y = hecho or devuelto # False z = dirigido or impreso # True print("\nOperador u-nario: not") print(w) print(x) print(y) print(z) es = True no_es = False print("\nOperadores u-narios") print(es) print(not es) print(no_es) print(not no_es)

La precedencia de las operaciones booleanas

Los operadores lógicos tienen una prioridad diferente y afecta el orden de evaluación.

Estos son los operadores en orden de prioridades: not, and, or

print("False or not False = ", False or not False) # True

Primero, se evalúa la parte not False.

Después de la evaluación, nos queda False o True. Esto da como resultado True.

Valores de verdad y falsedad

Python permite probar la veracidad de casi cualquier objeto. Cuando se utilizan con operadores lógicos, los valores de tipos no booleanos, como enteros o cadenas, se denominan truthy o falsy. Depende de si se interpretan como True o False.

Valores que Python considera falsos

None
False
0, 0.0, 0j
{}, (), [], ''
__bool__(), __len()__
Método que devuelve: 0, False


Evaluación de cortocircuito (Short-circuit)

También llamado Lazy.

Significa que el segundo operando en dicha expresión se evalúa solo si el primero no es suficiente para evaluar la expresión completa.

True or

lazy_or = True or "lo que sea" # La segunda expresión nunca se evalua, porque el primer argumento es True

False and

lazy_and = False and "nunca me evaluo" # La segunda expresión nunca se evalua, porque el primer argumento es False

# La segunda expresión nunca se evalua, porque el primer argumento es True lazy_or = True or "lo que sea" # True print("lazy_or = ", lazy_or) # La segunda expresión nunca se evalua, porque el primer argumento es False lazy_and = False and "nunca me evaluo" # False print("lazy_and = ", lazy_and) lazy_or = True or "$" # True print("lazy_or = ", lazy_or) lazy_and = False and 3.14 # False print("lazy_and = ", lazy_and)

or exclusivo, o simplemente XOR, es una operación lógica binaria.

Devuelve True solo si ambos argumentos son diferentes (uno es True, el otro es False).

Valor que es ninguno.

No es un valor en lo absoluto.

Use None de forma segura, cuando:

• Cuando se le asigna a una variable (o se devuelve como el resultado de una función).
• Cuando se compara con una variable para diagnosticar su estado interno.

Si una función no devuelve un cierto valor utilizando una cláusula de expresión return, se asume que devuelve implícitamente None.

Incluso si una declaración o expresión es sintácticamente correcta, puede causar un error cuando se intenta ejecutarla.

Los errores detectados durante la ejecución se denominan excepciones y no son incondicionalmente fatales.

Las excepciones son clases. cuando se genera una excepción, se crea una instancia de un objeto de la clase y pasa por todos los niveles de ejecución del programa, buscando la rama "except" que está preparada para tratar con la excepción.

Todas las excepciones integradas de Python forman una jerarquía de clases:

def jerarquia(thisclass, nest=0): if nest > 1: print(" |" * (nest - 1), end="") if nest > 0: print(" +---", end="") print(thisclass.__name__) for subclass in thisclass.__subclasses__(): jerarquia(subclass, nest + 1) jerarquia(BaseException)

Sin embargo, la mayoría de las excepciones no son manejadas por programas y dan como resultado mensajes de error.

Por ejemplo: NameError. Se genera cuando no se encuentra un nombre local o global. Esto se aplica solo a los nombres no calificados. El valor asociado es un mensaje de error que incluye el nombre que no se pudo encontrar.

Cada vez que tu código intenta hacer algo erroneo, irresponsable o inaplicable, Python hace dos cosas:

• Detiene tu programa.
• Crea un tipo especial de dato, llamado excepción.

Ambas actividades llevan por nombre lanzar una excepción.

Podemos decir que Python siempre lanza una excepción (o que una excepción ha sido lanzada) cuando no tiene idea de qué hacer con el código.

¿Entonces?

• La excepción lanzada espera que alguien o algo lo note y haga algo al respecto.
• Si la excepción no es resuelta, el programa será terminado abruptamente, y verás un mensaje de error enviado a la consola por Python.
• De otra manera, si se atiende la excepción y es manejada apropiadamente, el programa puede reanudarse y su ejecución puede continuar.

Python proporciona herramientas efectivas que permiten observar, identificar y manejar las excepciones eficientemente.

Esto es posible debido a que todas las excepciones potenciales tienen un nombre específico, por lo que se pueden clasificar y reaccionar a ellas adecuadamente.

Si el programa tiene un error no debería terminarse de manera abrupta, sino recuperarse a ese fallo y continuar su funcionamiento, aunque esa parte del código sea erronea.

Por ejemplo la división entre cero es un error: ZeroDivisionError: division by zero

Otro ejemplo es leer una colección pero acceder a un índice fuera de rango: IndexError: list index out of range

try-except: ¿Cómo manejar un error, con excepciones?

Se debe colocar el bloque de código que deseamos controlar, sabiendo de antemano que podría generar un error.

Para colocar el código en un bloque se utiliza la palabra reservada try, con lo cual estamos indicando, "intenta ejecutar este bloque y si ocurre un error entonces..."

print("Calculo 1...") try: r = 21 / 0 print("El resultado es: ", r) except: print("La división entre cero no es permitida") print("continuar") print("Calculo 2...") try: r = 21 / 7 print("El resultado es: ", r) except: print("La división entre cero no es permitida") print("continuar")

• try comienza con un bloque de código el cual puede o no estar funcionando correctamente.
• Python intenta ejecutar el código: si falla, se genera una excepción y Python comienza a buscar una solución.
• except comienza con un bloque de código que será ejecutado si algo dentro del bloque try sale mal.
• Se regresa al nivel de anidación anterior, es decir, se termina la sección try-except.

Si se esta familiarizado con las excepciones entonces podemos usarlas, además de que las excepciones se pueden anidar.

try: x = "a" y = 7 / x print(y) except ZeroDivisionError: print("No puedes dividir entre cero.") except ValueError: print("Se espera un valor entero.") except: print("Ocurrio un error al intentar hacer el calculo.") print("Continuar...")

Python 3 define 63 excepciones integradas, y todos ellos forman una jerarquía en forma de árbol, aunque el árbol es un poco extraño ya que su raíz se encuentra en la parte superior. Podemos decir que cuanto más cerca de la raíz se encuentra una excepción, más general (abstracta) es.

Exception es un caso especial de una clase más general llamada BaseException.

Por ejemplo: ArithmeticError es una clase general que incluye (entre otras) la excepción ZeroDivisionError.

try: y = 1 / 0 except ZeroDivisionError: print("¡División entre Cero!") # Excepción lanzada except ArithmeticError: print("¡Problema aritmético!")

try: y = 1 / 0 except ArithmeticError: print("¡Problema aritmético!") # Excepción lanzada except ZeroDivisionError: print("¡División entre Cero!")

Se pueden manejar dos o mas excepciones de la misma manera, usando la siguiente sintaxis:

try: : except (exc1, exc2): :

as

Cuando ocurre una excepción, puede tener un valor asociado, también conocido como el argumento de la excepción.

La presencia y el tipo de argumento depende del tipo de excepción.

La cláusula except puede especificar una variable después del nombre de excepción.

La variable se vincula a una instancia de la excepción con los argumentos almacenados en instance.args.

Por conveniencia, la instancia de excepción define __str__() para que se pueda mostrar los argumentos directamente, sin necesidad de hacer referencia a .args.

También se puede instanciar la excepción primero, antes de generarla, y agregarle los atributos que se desee

try: i = int("Hola mundo!") except Exception as e: print(e) # invalid literal for int() with base 10: 'Hola mundo!' print(e.__str__()) # invalid literal for int() with base 10: 'Hola mundo!'



try: num_list = [10] num_list += 5 except Exception as error: error_string = str(error) print(error_string)

raise

La instrucción raise genera la excepción especificada denominada exc como si fuese generada de manera natural:

raise exc

La instrucción permite:

• Simular excepciones reales (por ejemplo, para probar tu estrategia de manejo de excepciones).
• Parcialmente manejar una excepción y hacer que otra parte del código sea responsable de completar el manejo.

Las declaraciones try … except tienen un bloque else opcional, el cual, cuando está presente, debe seguir a los except.

Es útil para aquel código que debe ejecutarse si el bloque try no genera una excepción.

El uso de la cláusula else es mejor que agregar código adicional en la cláusula try porque evita capturar accidentalmente una excepción que no fue generada por el código que está protegido por la declaración try … except.

def divide(x, y): try: result = x / y except ZeroDivisionError: print("division by zero!") else: print("result is", result) finally: print("executing finally clause") divide(2, 1) # result is 2.0 # executing finally clause divide(2, 0) # division by zero! # executing finally clause divide("2", "1") # executing finally clause

La cláusula finally se ejecuta independientemente de que la cláusula try produzca o no una excepción.

• Si ocurre una excepción durante la ejecución de la cláusula try, la excepción podría ser gestionada por una cláusula except.
  
  Si la excepción no es gestionada por una cláusula except, la excepción es relanzada después de que se ejecute el bloque de la cláusula finally.
• Podría aparecer una excepción durante la ejecución de una cláusula except o else.
  
  De nuevo, la excepción será relanzada después de que el bloque de la cláusula finally se ejecute.
• Si el bloque try llega a una sentencia break, continue o return, la cláusula finally se ejecutará justo antes de la ejecución de dicha sentencia.
• Si una cláusula finally incluye una sentencia return, el valor retornado será el de la cláusula finally, no la del de la sentencia return de la cláusula try.

def divide(x, y): try: result = x / y except ZeroDivisionError: print("division by zero!") else: print("result is", result) finally: print("executing finally clause") divide(2, 1) # result is 2.0 # executing finally clause divide(2, 0) # division by zero! # executing finally clause divide("2", "1") # executing finally clause

assert expresión

La declaración raise permite al programador forzar a que ocurra una excepción específica.

raise NameError('Hola mundo')

El único argumento de raise indica la excepción a generarse. Tiene que ser o una instancia de excepción, o una clase de excepción (una clase que hereda de Exception).

¿Como funciona?

• Evalúa la expresión.
• Si la expresión se evalúa como True (verdadero), o un valor numérico distinto de cero, o una cadena no vacía, o cualquier otro valor diferente de None, no hará nada más.
• De lo contrario (se evalúa como False (falso)), automáticamente e inmediatamente genera una excepción llamada AssertionError (en este caso, decimos que la afirmación ha fallado).

assert 5 < 0

Se lanza AssertionError y el programa termina.

Con un argumento, devuelve el tipo de objeto.

Con tres argumentos, devuelve un nuevo tipo de objeto.

Si necesita saber el tipo de un objeto, simplemente imprímalo usando la función type().

Python es un lenguaje dinámicamente y fuertemente tipado.

La escritura dinámica significa que solo los objetos en tiempo de ejecución (valores) tienen un tipo, pero no las variables que los almacenan.

Puede almacenar varios valores de diferentes tipos en una sola variable durante la ejecución del código y no se producirán errores.

Lo cual significa que puede cambiar el tipo de una variable al asignar un valor con tipo de dato distinto al inicial:

>>> saludo = "Hola mundo" >>> print(type(saludo)) <class 'str'> >>> saludo = 1.1 >>> print(type(saludo)) <class 'float'>

Weak typing

El mismo operando puede dar resultados diferentes dependiendo de los tipos de argumentos proporcionados.

Por ejemplo, puede agregar dos cadenas para obtener una concatenación. También es posible multiplicar una cadena por un número entero

print(125 + 125) # "250" print("125" + "125") # "125125" print(125 * 4) # "500" print("125" * 4) # "125125125125" print("This is a number:", 125) # "This is a number: 125"

Explicit type casting

El proceso de convertir un valor en otro tipo también se denomina conversión de tipos.

Aunque la conversión de tipos implícitos no está permitida en Python, a menudo se encontrará en la necesidad de definir una conversión de tipos explícita dentro de su código.

Si no se permite la conversión entre dos tipos, verá un error.

En Python existen varios tipos de colecciones para almacenar datos en Python.

Las colecciones de elementos ordenados posicionalmente generalmente se denominan secuencias, y tanto las listas como las cadenas les pertenecen.

Cada elemento de una lista, así como cada carácter de una cadena, tiene un índice que corresponde a su posición.

Los índices se utilizan para acceder a elementos dentro de una secuencia. La indexación se basa en cero.

La siguiente instrucción permite conocer la posición de un caracter en un string.

>>> vocales = "aeiou"
>>> print(vocales.index("i"))
2
¡Oh si!, la numeración inicia desde cero
Entonces para visualizar de alguna manera esto sería:
01234
aeiou
Donde la posición del caracter "i" es la número 2

Para acceder a un elemento de una lista por su índice, debe escribir el nombre de la lista, seguido de corchetes y, entre ellos, escribe el índice de un elemento que desea obtener.

No olvide que los índices comienzan en 0, por lo que el índice del primer elemento es 0.

El índice del último elemento es igual a len(lista) - 1.

Donde len() es una función que recibe como parametro una colección y regresa el número de elementos que contiene.

Matrices y Cadenas

# Matrices semana = ["Lunes","Martes","Miercoles","Jueves","Viernes"] primer_dia = semana[0] segundo_dia = semana[1] ultimo_dia = semana[len(semana)-1] print(primer_dia, segundo_dia, ultimo_dia) # Cadenas saludo = "Hola" print(saludo[0]) print(saludo[1]) print(saludo[len(saludo) - 1])

IndexError

Si trata de acceder a un índice que no este en el rango de su secuencia obtendrá un error llamado IndexError

saludo = "Hola" print(saludo[len(saludo) + 1])

En Python Sin embargo, cuando se trata de cadenas, la reasignación es imposible.

Las cadenas, a diferencia de las listas, son inmutables, por lo que no puede modificar su contenido con índices. Al intentar hacer esto indica el error El objeto 'str' no admite la asignación de elementos

saludo = "Hola" saludo[0] = "X"

Sin embargo en las listas si es posible la reasignación:

semana = ["Lunes","Martes","Miercoles","Jueves","Viernes"] primer_dia = semana[0] print(primer_dia) semana[0] = "Domingo" primer_dia = semana[0] print(primer_dia)

índices negativos

La forma más fácil de acceder a los elementos al final de una lista o una cadena es usar índices negativos.

El menos antes del número cambia tu perspectiva de alguna manera y miras la secuencia desde el final. Entonces, el último elemento de una lista, en este caso, tiene el índice igual a -1, y el primer elemento de la lista tiene el índice -len(lista) (la longitud de la lista).

semana = ["Lunes","Martes","Miercoles","Jueves","Viernes"] primer_dia = semana[-len(semana)] print(primer_dia) ultimo_dia = semana[-1] print(ultimo_dia)

split() ayuda a convertir un valor a una lista.

Python admite operaciones aritméticas básicas como:

• Suma +
• Resta -
• Multiplicación *
• División /
  66 / 10 # 6.6
  
• División entera //
  77 / 10 # 6
  

Python genera un error si intenta dividir por cero: ZeroDivisionError: division by zero

El operador de módulo de Python % se usa para obtener el resto de una división.

Puede resultar útil cuando desee comprobar si un número es par. Para los números impares devuelve 1 y para los pares devuelve cero.

if((10%2) == 0):print("par") if((10%2) == 1):print("impar")

Practique y vea los resultados, por ejemplo que sucede cuando uno de los números es decimal o cuando uno de los números tiene signo negativo.

Recuerda la prioridad de los operadores es importante: paréntesis, potencia, unario menos, multiplicación, división y resto, Adición y sustracción

Es posible obtener una parte de un string.

>>> print(c)
Hola Mundo
>>> print(c[5:10])
Mundo
>>> print(c[0:4])
Hola

La lista es un tipo de dato en Python que se utiliza para almacenar múltiples objetos. Es una colección ordenada y mutable de elementos separados por comas entre corchetes

Una lista contiene elementos o items de cualquier tipo de dato separados por comas (,) y esta lista esta encerrada o contenida entre corchetes []

>>> lista = [1,"a","palabra", 0]
>>> print(lista[2])
palabra

Dentro de la jerga de Python se dice que una lista es mutable, es decir, que puede ser alterada o cambiada.
Mejor con un ejemplo:
>>> print(lista)
[1, 'a', 'palabra', 0]
>>> lista[2] = "python"
>>> print(lista)
[1, 'a', 'python', 0]
>>> print(lista[2])
python

Otra forma de crear listas es a través de la función list() la cual creaa una lista a partir de un objeto iterable: es decir, un tipo de objeto en el que puede obtener sus elementos uno por uno. Tiene un parámetro que es de tipo string o se puede crear una lista vacía al omitir el parámetro.

list("Hola")

En este caso el string "Hola" es divido caracter por caracter, por tanto, cada caracter corresponde a un elemento en la lista:

['H', 'o', 'l', 'a']

La función list() toma su argumento (una cadena) y crea una nueva lista que contiene todos los caracteres de la cadena, uno por elemento de la lista.

Operadores in, in not

El operador in puede ser usado para evaluar si un elemento esta contenido en una lista.

El operador in not puede ser usado para evaluar si un elemento no esta contenido en una lista.

lst = list("Hola mundo") print("H" in lst) print("5" not in lst)



Función len()

Hay una función incorporada llamada len() que se puede aplicar a cualquier objeto iterable y devuelve simplemente la longitud de ese objeto.

len(objeto_iterable)

Método append()

Toma el valor de su argumento y lo coloca al final de la lista que posee el método.

Método insert()

Puede agregar un nuevo elemento en cualquier lugar de la lista, no solo al final.

lista = ["mundo!"] lista.insert(0,"Hola") print(lista)

Da acceso a un rango específico de elementos de secuencia.

secuencia [start:stop[:step]]

start

Opcional. Índice inicial del corte. El valor predeterminado es 0.

stop

Opcional. El último índice del sector o la cantidad de elementos que se van a obtener. El valor predeterminado es len(secuencia).

step

Opcional. Sintaxis de segmento extendida. Valor de paso de la rebanada. Por defecto es 1.

vehiculos = ['carro', 'bicicleta', 'moto','avión','barco','helicoptero'] print(vehiculos[1:]) print(vehiculos[2:]) print(vehiculos[3:]) print(vehiculos[:1]) print(vehiculos[:2]) print(vehiculos[:3])

Nota: los índices pueden ser negativos

in - not in pueden ser de utilidad para saber si un elemento se encuentra o no en una lista.

lst = list("Hola") print("a" in lst) print("x" not in lst)

Ordena los elementos de una lista

Este método ordena la lista en su lugar, utilizando solo < comparaciones entre elementos.

Las excepciones no se suprimen: si falla alguna operación de comparación, la operación de clasificación completa fallará (y la lista probablemente se dejará en un estado parcialmente modificado).

lst = ["P", "y", "t", "h","o","n"] lst.sort() print(lst) # ['P', 'h', 'n', 'o', 't', 'y']

La funcion sorted(iterable, *, key=None, reverse=False) Devuelve una nueva lista ordenada de los elementos en iterable.

Invierte el orden de los elementos de una la lista.

fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana'] print("Lista: ", fruits) # ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana'] print("¿Cuantas apple?", fruits.count('apple')) # 2 print("¿Cuantas tangerine?", fruits.count('tangerine')) # 0 print("El index de banana:", fruits.index('banana')) # 3 print("El index 4 banana", fruits.index('banana', 4)) # Find next banana starting a position 4 # 6 fruits.reverse() print("Orden invertido", fruits) # ['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange'] fruits.append('grape') print("Se agregó grape", fruits) # ['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape'] fruits.sort() print("Lista ordenada", fruits) # ['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear'] fruits.pop() print("Elimina el último", fruits)

Una secuencia es un tipo de dato en Python capaz de almacenar mas de un valor (o ninguno si la secuencia esta vacía), los cuales pueden ser secuencialmente examinados, elemento por elemento.

Una secuencia es un tipo de dato que puede ser escaneado por el bucle for.

list es una secuencia.

Propiedad de cualquier tipo de dato en Python que describe su disponibilidad para poder cambiar libremente durante la ejecución de un programa.

Existen dos tipos de datos en Python: mutables e inmutables.

Los datos mutables pueden ser actualizados libremente en cualquier momento, a esta operación se le denomina "in situ".

Lo primero que distingue una lista de una tupla es la sintaxis empleada para crearlas.

Las tuplas utilizan paréntesis, mientras que las listas usan corchetes, aunque también es posible crear una tupla tan solo separando los valores por comas.

Una tupla es una secuencia inmutable. Se puede comportar como una lista pero no puede ser modificada en el momento.

Una tupla es un conjunto de elementos, separados por comas (,) encerrados o contenidos entre paréntesis ()

Si se necesita definir una tupla de un solo elemento, es necesario incluir una coma (,), lo que estaría indicando que se trata de una tupla.

>>> t = ("x",)

tuplaVacia = ()

Si se desea crear una tupla de un solo elemento, se debe de considerar el hecho de que, debido a la sintaxis (una tupla debe de poder distinguirse de un valor entero ordinario), se debe de colocar una coma al final: t = ("x",)

El quitar las comas no arruinará el programa en el sentido sintáctico, pero serán variables no tuplas.

Si se intenta cambiar el valor de un tupla se genera el error:

TypeError: 'tuple' object does not support item assignment

El operador + puede unir tuplas.

El operador * puede multiplicar las tuplas.

Los operadores in y not in pueden ser aplicados a las tuplas.

Las Tuplas son colecciones de datos ordenadas e inmutables, no se puede agregar, modificar, cambiar o quitar elementos.

Cada elemento de la tupla puede ser de un tipo de dato diferente Las tuplas pueden contener otras tuplas o listas (y viceversa).

Tupla vacía: t = ()

También se puede crear una tupla utilizando la función integrada de Python tuple().

La función len() permite conocer el número de elementos contenidos en una tupla.
>>> t1 = (10,20,30)
>>> len(t1)
3

min(tupla). Obtiene o regresa el primer elemento en la lista.
max(tupla). Obtiene o regresa el último elemento en la lista.
>>> t = ("x","y","z")
>>> min(t)
'x'
>>> max(t)
'z'

Si tiene una lista pero quiere convertirla en tupla use tuple(lista)
>>> l = ["a","b","c"]
>>> tupla = tuple(l)
>>> print(l)
['a', 'b', 'c']
>>> print(tupla)
('a', 'b', 'c')

Diccionario. Permite almacenar objetos Python, es mutable.

Son colecciones indexadas de datos, mutables y desordenadas.

Los diccionarios utilizan llaves a diferencia de listas y tuplas.

Consiste del par: clave y valor.

Cada clave debe de ser única. No es posible tener una clave duplicada.

Una clave puede ser un tipo de dato de cualquier tipo: puede ser un número (entero o flotante), o incluso una cadena.

Un diccionario almacena pares de valores.

Si necesita correlacionar datos y valores use diccionarios.

Hash. Convertir un valor en otro.

En la jerga de Python un diccionario se conoce como tablas hash.

Sintaxis

El conjunto de claves valor son encerrados o contenidos entre llaves (curly braces)

{ } # Diccionario vacío

Cada par clave y valor es separado por comas (,)

Al escribir el par clave y valor, escriba entre comillas (") el nombre o identificador de la clave.

A continuación escriba dos puntos (:) para indicar que despues de los dos puntos se asigna un valor.

>>> fecha = { "anio": 2020, "mes": "septiembre","dia": 7 }
>>> print(fecha)
{'anio': 2020, 'mes': 'septiembre', 'dia': 7}

La lista de todos los pares es encerrada con llaves, mientras que los pares son separados por comas, y las claves y valores por dos puntos.

Los diccionarios no son listas - no guardan el orden de sus datos, el orden no tiene significado.

El orden en que un diccionario almacena sus datos esta fuera de nuestro control, lo que es normal.

Método keys()

El método retorna o regresa una lista de todas las claves dentro del diccionario. Al tener una lista de claves se puede acceder a todo el diccionario de una manera fácil y útil.

Método item()

Este método regresa una lista de tuplas donde cada tupla es un par de cada clave con su valor.

Método values()

Regresa una lista de valores

Modificar, agregar y eliminar

# Modificar motos = {"Kawasaki" : "N", "Susuki" : "Hayabusa GSX-1200R", "Honda" : "CBR1100XX", } motos["Kawasaki"] = "Ninja H2R" print(motos) # Agregar motos["Yamaha"] = "R1 YZF" print(motos) # Update motos.update({"Marine Turbine Technologies" : "MTT Y2K"}) print(motos) # Eliminar del motos["Honda"] print(motos) motos.popitem() # Elimina último elemento print(motos) # Eliminar una clave no existente, provocará un error. # Copiar m = motos.copy() print(m)

La función print() envía datos a la consola..

Con la función input() podemos capturar la entrada del teclado. Los datos de entrada que queremos obtener no son más que un valor introducido por el usuario. Cualquier dato pasado a esta función se trata como una secuencia de caracteres (cadena).

El resultado de la función input() es una cadena.

La función input() deja de esperar la entrada del usuario, hasta que el usuario da ENTER

La función input() puede tomar un argumento opcional, que es un mensaje:

>>> lectura = input("Ingrese letras, números o símbolos y de enter... ")
Ingrese letras, números o símbolos y de enter... El valor de pi es de: 3.14
>>> lectura
'El valor de pi es de: 3.14'

---

>>>respuesta = input("¿Qué día de la semana es hoy? ")
>>>print("Hoy es", respuesta,", gracias!") Hoy es Viernes , gracias!

Cualquier valor que ingrese, la función lo verá como una cadena. No importa si ingresa dígitos o letras, la entrada se convertirá en una cadena.

Si desea que un número sea un número, debe escribirlo explícitamente:

print("Ingrese un número entero:") num = int(input())

Si un usuario ingresa un valor no entero, aparecerá un error.

Una función permite dividir el código en bloques organizados y reusables, empleados para realizar una acción específica.

No se debe invocar una función antes de que se haya definido.

Los parámetros solo existen dentro de las funciones (este es su entorno natural).

Los argumentos existen fuera de las funciones, y son los que pasan los valores a los parámetros correspondientes.

La técnica que asigna cada argumento al parámetro correspondiente, es llamada paso de parámetros posicionales, los argumentos pasados de esta manera son llamados argumentos posicionales.

Una variable que existe fuera de una función tiene alcance dentro del cuerpo de la función, excluyendo a aquellas que tienen el mismo nombre..

Funciones vs. métodos

Un método es un tipo específico de función: se comporta como una función y se parece a una función, pero difiere en la forma en que actúa y en su estilo de invocación.

Una función no pertenece a ningún dato: obtiene datos, puede crear nuevos datos y (generalmente) produce un resultado.

Un método es similar a una función, pero también puede cambiar el estado de una entidad seleccionada.

Un método es propiedad de los datos para los que trabaja, mientras que una función es propiedad de todo el código.

Invocar un método requiere alguna especificación de los datos a partir de los cuales se invoca el método.

El nombre del método está precedido por el nombre de los datos que posee el método. A continuación, se agrega un punto, seguido del nombre del método y un par de paréntesis que encierran los argumentos.

Python usa la indentación para establecer el ámbito (scope)

A diferencia de otros programas que usan { } para ello.

print() es una función incorporada de Python.

La keyword def permite definir funciones al codificador de Python.

La sintaxis para declarar una función es la siguiente:

def nombreFuncion(argumentos):
   sentencias
   return expresión

Los dos puntos después de los parentesis que encierran los argumentos indican que inicia la función.

Todo el cuerpo de la función debe ir indentado (4 espacios), lo que esta indentado, no pertenecera a la función.

¿Qué es un argumento? un valor, que se usará dentro del cuerpo de la función.

Después de def, escriba el nombre de la función y los nombres de los parámetros, que la función puede aceptar, entre paréntesis. No olvidar los dos puntos al final de la línea. Los nombres de una función y sus parámetros siguen la misma convención que los nombres de las variables, es decir, deben escribirse en minúsculas con guiones bajos entre las palabras.

Puede hacer cálculos dentro de la función y usar la palabra clave return para devolver el resultado.

Solo cuando no hay sangría, finaliza la definición de la función.

Posteriormente, los parámetros toman valores pasados en una llamada de función. Los valores que pasamos a una función se conocen como argumentos.


En caso de que no desee pasar ningún argumento, los corchetes permanecen vacíos.

pass

La sentencia pss no hace nada.

Se puede usar cuando se requiere una declaración sintácticamente pero el programa no requiere ninguna acción.

Esto se usa comúnmente para crear clases mínimas:

class MyEmptyClass: pass

También puede declarar una especie de función vacía con la declaración pass:

# Esta función no hace nada (todavía) def lazy_func(param): pass

Cuando elige llamar a lazy_func() con un valor arbitrario como argumento, no sucederá nada. Así que pass es solo un placeholder, pero al menos su código será válido con él.

Los parámetros son solo alias de valores, que se pueden pasar a una función.

def fx(param_1, param_2): print(param_1,param_2) arg_1 = "Hola" arg_2 = "mundo" fx(arg_1,arg_2)

Los parámetros de una función son simplemente alias o placeholder para los valores que les pasará.

Los parámetros se reinicializan cada vez que llama a la función. Dentro de la función, tiene acceso a estos valores, lo que significa que puede realizar cálculos sobre ellos.

La palabra clave return se usa para indicar qué valores genera la función (como salida o devolución). Básicamente, es el resultado de la llamada a la función.

def fx(param_1, param_2): return param_1 + param_2 arg_1 = 7 arg_2 = 3 print(fx(arg_1,arg_2))

El intérprete de Python deja de realizar la función después de return.

Pero, ¿qué pasa si el cuerpo de la función contiene más de una declaración de retorno? Entonces la ejecución terminará después de la primera.

Una función puede simplemente realizar una acción sin devolver nada o devolver un resultado específico. Si su función no devuelve nada, asignar su resultado a una variable o imprimirlo le dará None.

Python ofrece otra manera de pasar argumentos, donde el significado del argumento esta definido por su nombre, no su posición, a esto se le denomina paso de argumentos con palabras clave.

En Python se pueden invocar funciones con sus parámetros con nombre junto con su valor, el intérprete de Python determina a qué argumentos proporcionar los valores. No se tiene que invocar la función con los argumentos, en un orden particular solamente proporciona los nombres junto con los valores.

def datos(nombre, ap, am, edad, genero):
    print("NOMBRE: ", nombre, "PATERNO: ", ap, "MATERNO: ", am, "EDAD: ", edad, "GENERO: ", genero)

datos(ap = "Paterno", genero = "masculino", nombre = "Homero", edad = 5, am = "Materno")

Es posible combinar ambos tipos si se desea, solo hay una regla inquebrantable: se deben colocar primero los argumentos posicionales y después los de palabras clave.

En Python es posible indicar que una función recibe 0 o n argumentos.

Para ello solo debe definir un argumento anteponiendo a este el caracter *

def data(*a):
    dato = 1
    for x in a:
        print("Argumento número ", dato, " Valor: ", str(x))
        dato = dato + 1
    return dato

data("v", "a", "r", "i", "o", "s", "argumentos", "-", 3.14)

Es posible que el valor de un argumento tenga un valor por defecto.

Esto es posible al definir el valor del argumento en la definición de los argumentos de la función, con la condición que los argumentos por defecto sean declarados al final de la lista de argumentos, de lo contrario Python indicará: non-default argument follows default argument

def porDefecto(a, b, c, pi=3.14):
    print(pi)
    print(a)
    print(b)
    print(c)

porDefecto(a = 10, b = 20, c = 20)
porDefecto(10, 9, 8)
porDefecto(10, 9, 8, 3.1416)
porDefecto(a = 100, b = 200, c = 300, pi = 5)

Existe un método especial en Python el cual puede extender el alcance de una variable incluyendo el cuerpo de las funciones para poder no solo leer los valores de las variables sino también modificarlos.

Este efecto es causado por la palabra reservada llamada global

Cuando Python inicia la ejecución de un programa, es necesario indicar por donde iniciar, para ello se utiliza la siguiente sintaxis:

if __name__ == "__main__":
    funcion_inicial()

Ejemplo:

def fx():
    Print(2 + 2)

def clasica():
    Print("Hello world")

def hoy():
    respuesta = input("¿Qué día de la semana es hoy? ")
    print("Hoy es", respuesta, " gracias!")

if __name__ == "__main__":
    hoy()

¿Qué día de la semana es hoy?

La función int() toma un argumento e intenta convertirlo a un valor entero;

La función float() toma un argumento e intenta convertirlo a flotante.

¿Para que sirve una estructura de control: if

Sirve para que se ejecute alguna parte del código solo si una condición particular es verdadera.

Tal parte del código debe colocarse dentro del cuerpo de una declaración if.

Seguida de una condición y la una lista de expresiones a ejecutar (si conoces otros lenguajes de programación no lleva parantesis, aunque se pueden colocar).

La condición es siempre una expresión booleana, es decir, su valor es Verdadero o Falso.

Si conoces otros lenguajes de programación encontraras que el inicio de un bloque o ámbito de una función o estructura de control if es el sangrado o sangría normalmente 4 espacios (indentado Este término significa mover un bloque de texto hacia la derecha insertando espacios o tabuladores, para así separarlo del margen izquierdo y distinguirlo mejor del texto adyacente), fuera de este no se reconoce como parte del if.

El inicio del bloque es con dos puntos (:) tanto para una función como para un if.

Un fragmento de código en el que todas las líneas están en el mismo nivel de sangría se denomina bloque de código.

En Python, solo se usa sangría para separar diferentes bloques de código.

En esta estructura si un caso no se cumple se puede pasar al caso contrario con un else:, nuevamente si conoces otros lenguajes de programación tendrás que practicar para acostumbrarte a escribir dos puntos después del else:.

elif

Para varios casos se usa elif (si conoces otro lenguaje pensaras que esta mal escrito, pero así es correcto).

La declaración Elif se usa cuando queremos especificar varias condiciones en el código.

La declaración Elif difiere de else en un momento clave: representa otra opción específica, mientras que else se ajusta a todos los casos que no caen en la condición dada en la declaración if.

Si conoces otros lenguajes, en Python else no tiene un fin de bloque

def init(): a, b = 2, 4 print(a, b) if (a < b): r = "x es menor que y" elif (a == b): r = "x es igual que y" else: r = "x es mayor que y" print(r) if __name__ == "__main__": init()

El código dentro del bloque else se ejecuta solo si todas las condiciones anteriores son falsas.

Los condicionales con múltiples ramas forman un árbol de decisión, en el que un nodo es una expresión booleana y las ramas se marcan con Verdadero o Falso. La rama marcada como Verdadero conduce a la acción que debe ejecutarse y la rama Falsa conduce a la siguiente condición.

Una declaración if-else es otro tipo de expresiones condicionales en Python.

Se diferencia de una instrucción if por la presencia de la palabra clave adicional else.

El bloque de código que else contiene se ejecuta cuando la condición de su declaración if no se cumple (el valor booleano es Falso).

Dado que una instrucción else es una alternativa para una instrucción if, solo se puede ejecutar un bloque de código. Además, else no requiere ninguna condición:

idioma = "es" if idioma == "es": print("Hola mundo!") else: print("Hallo Welt")

Si conoces otros lenguajes, esta estructura es similar al operador ternario.
En Python se puede hacer uso de esta estructura escribiendola en una sola línea.

def init(): condicion = "verdadero" if ("a" == "a") else "falso" print(condicion) condicion = "verdadero" if ("b" == "a") else "falso" print(condicion) if __name__ == "__main__": init()

alternativa_1 if condición else alternativa_2

idioma = "es" print("Hola mundo!" if idioma == "es" else "Hallo Welt")

Las declaraciones if-else pueden anidarse de la misma manera que las declaraciones if.

Puede aparecer una expresión condicional adicional después de la sección if y después de la sección else.

Una vez más, no olvide aplicar la sangría correctamente

dia = "Jueves" if dia == "Lunes": print('Lunes') else: if dia == "Martes": print('Martes') else: print('Miercoles') print('Mañana será Jueves!')

Loops permiten que un bloque de código se ejecute de manera iterativa o repetitiva.
Python solo tiene los tipos de loops: while , for

break empleado para interrumpir la iteración de un loop. Sale del ciclo inmediatamente, e incondicionalmente termina la operación del ciclo; el programa comienza a ejecutar la instrucción más cercana después del cuerpo del ciclo.
continue Se comporta como si el programa hubiera llegado repentinamente al final del cuerpo; el siguiente turno se inicia y la expresión de condición se prueba de inmediato.
pass para indicar que no se ejecute una sentencia.

Repite un bloque de código (aunque pueda contener una sola línea) mientras una condición de control sea verdadera.


Fuente: https://hyperskill.org/learn/step/5940

Cuando la condición de control es falsa se interrumpe el ciclo.

Recuerda el sangrado (indentado), para definir el ámbito y los dos puntos (:) para indicar su inicio.

while (<condición>): sentencia

El ciclo while ejecuta una sentencia o un conjunto de declaraciones siempre que una condición booleana especificada sea verdadera por ejemplo:
i = 0 limite = 5 while(i < limite): print("iteración: ", i) i = i + 1

Repite un bloque de código (aunque pueda contener una sola línea) mientras una condición de control es definida por un rango: desde-hasta.

Se usa para iterar sobre una secuencia.

En el caso del for:

• No es necesario hacer el incremento de la variable de control
• Se usa range(<mínimo><máximo>, step) para determinar el valor inicial y final de la condición de control.
  Donde range() es una función para obtener el rango de los números.
• La función range() solo acepta enteros como argumentos y genera secuencias de enteros.
• La función range() también puede aceptar tres argumentos: Echa un vistazo al código del editor.
  El tercer argumento es un incremento: es un valor agregado para controlar la variable en cada giro del ciclo (el valor predeterminado del incremento es 1 ).
• Si el conjunto generado por la función range() está vacío, el ciclo no ejecutará su cuerpo en absoluto.
• Los bucles for de Python son los llamados iteradores, por lo tanto se puede iterar sobre una colección.
• También se usa la función enumerate(<índice>, <valor>), la cual además regresa el índice de los elementos de una colección.

Recuerda el sangrado (indentado), para definir el ámbito y los dos puntos (:) para indicar su inicio.

min = 0 max = 5 for i in range(min, max): print("iteración: ", i)

Iteradores
vocales = ["a", "e", "i", "o", "u"] for v in vocales: print("iterador: ", v)

Ejemplo break (sale del ciclo o rompe el ciclo y no termina el ciclo completo)
vocales = ["a", "e", "i", "o", "u"] for v in vocales: if(v == "i"): break print("iterador: ", v)

Ejemplo continue (ignora la iteración que cumpla con la condición y continua con el ciclo)
vocales = ["a", "e", "i", "o", "u"] for v in vocales: if(v == "i"): continue print("iterador: ", v)

Ejemplo enumerate(índice, valor)
for i, e in enumerate(vocales): if(e == "a"): continue print("iterador: ", i, " elemento: ", e)

El protocolo iterador es una forma en que un objeto debe comportarse para ajustarse a las reglas impuestas por el contexto de las sentencias for e in. Un objeto conforme al protocolo iterador se llama iterador.

Hay dos funciones específicas para trabajar con iteradores.

1. Devuelve verdadero si el objeto o admite el protocolo de iterador. Esta función siempre tiene éxito.
   
   __iter__() el cual debe devolver el objeto en sí y que se invoca una vez (es necesario para que Python inicie con éxito la iteración).


2. Retorna el siguiente valor de la iteración o.
   
   El objeto debe ser un iterador (depende de quién llama comprobar esto).
   
   Si no quedan valores restantes, retorna NULL sin establecer ninguna excepción.
   
   Si se produce un error al recuperar el elemento, retorna NULL y pasa la excepción.
   
   __next__() el cual debe devolver el siguiente valor (primero, segundo, etc.) de la serie deseada: será invocado por las sentencias for/in para pasar a la siguiente iteración; si no hay más valores a proporcionar, el método deberá lanzar la excepción StopIteration.

La expresión yield se usa al definir una función generator o una función generator asynchronous y, por lo tanto, solo se puede usar en el cuerpo de una definición de función.

El uso de una expresión yield en el cuerpo de una función hace que esa función sea un generador, y su uso en el cuerpo de una async def hace que esa función de rutina sea un generador asincrónico.

Una sentencia yield es semánticamente equivalente a una expresión yield.

La sentencia yield se puede utilizar para omitir los paréntesis que de otro modo serían necesarios en la declaración de expresión de rendimiento equivalente.

Existe un documento que se llama PEP 8 (Python Enhancement Proposal - Propuesta de mejora de Python). La idea clave es usar el mismo estilo de código para todos los proyectos de Python como si fueran escritos por el mismo programador.

Este documento garantiza que incluso un principiante comprenderá fácilmente el código escrito por cualquier otro desarrollador.

Existen diferentes tipos de PEP y el más útil para los principiantes es el PEP informativo.

Los PEP de este tipo suelen describir pautas o convenciones comúnmente aceptadas sobre el idioma, por lo que pueden ser muy útiles.

Además de PEP 8, que es una guía de estilo oficial, otro gran PEP a tener en cuenta es el PEP 20 Zen de Python.

La longitud de una línea

No utilice más de 79 caracteres en una línea de código.

Las líneas más cortas se ven mejor en los editores de código. Durante este curso, aprenderemos varias formas de lograrlo.

Evite espacios extra

A veces, puede agregar algunos espacios incluso si realmente no los necesita. Esto reducirá la legibilidad de su código.

Evite espacios adicionales entre paréntesis.

En lo personal hoy en día he visto algunos programadores adoptar un estilo personal que adopte cuando programaba y es colocar espacios para según yo mayor legibilidad, es decir, contrario a lo que dicta el PEP, aunque siento que su punto de vista es Evite espacios adicionales .

Comillas

Es posible usar comillas simples o dobles para definir cadenas. Elija un estilo y utilícelo constantemente en su código.

La única recomendación en PEP 8 es que si una cadena contiene comillas simples o dobles, debe usar la otra para evitar barras diagonales inversas.

Con Python puedes escribir código como procedimientos o código como objetos.

Escribir código orientado a objetos usando clases las cuales se puede encapsular la funcioncionalidad.

Recuerda que en la programación todo trata de ordenarse, estructurarse, organizarse de una manera lógica, el truco esta en entender ese pensamiento o filosofia y listo!.

Una clase se define usando la keyword class

class nombreClase():

Métodos

Comenzaremos por una parte de la estructura de una clase, diciendo que, una clase puede tener métodos. Estos métodos son definidos como funciones.

Es aquí donde cada autor en su afán de explicar de manera pura o de una manera particular (ya sea porque es su estilo o ya sea por intentar ser claro), en mi experiencia esto en ocasiones trae confusión, cuando ya más o menos entendí la programación siempre opte por las formas puras u ortodoxas, en lo personal considero es lo mejor (ahora con la edad he perdido ese estilo).

Usualmente el primer argumento de cualquiera de los métodos de una clase es el argumento de uno mismo y el argumento de uno mismo se refiere al objeto en sí.

Método es una función que está dentro de una clase.

Un método está obligado a tener al menos un parámetro self, no existen métodos sin parámetros; un método puede invocarse sin un argumento, pero no puede declararse sin parámetros.

Al invocar un método, no se debe pasar el argumento para el parámetro self, Python lo gestiona de manera automática e interna.

class Clase: attr = 1 def metodo(self): print("Hola método") obj = Clase() obj.metodo()

self

En otros lenguajes esto se conoce como this

El parámetro self es usado para obtener acceso a la instancia del objeto y las variables de clase.

• Si omite self en la definición del método, se genera un error TypeError: metodo() takes 0 positional arguments but 1 was given
• Si omite anteponer self para acceder a la variable de clase se genera un error, NameError: name 'attr' is not defined

class Clase: attr = 1 def metodo(self): # sin self, TypeError: metodo() takes 0 positional arguments but 1 was given print("Hola método", self.attr) # sin self, NameError: name 'attr' is not defined obj = Clase() obj.metodo()

self también se usa para invocar otros métodos desde dentro de la clase.

class Clase: attr = 1 def metodo(self): print("Hola método") self.suma() def suma(self): print(self.attr + self.attr) obj = Clase() obj.metodo()

[ Python apareció en 1991, Java 5 años después (1996), sin embargo Eiffel apareció en 1985 pero C++ dos años antes (1983), esto según wikipedia ].

Bien, una forma de entender una clase podría ser visualizarla como una plantilla o molde, donde a través del uso de esta plantilla o molde se obtiene algo a lo cual llamaremos objeto, cuando se crea un objeto se dice que se instancia la clase.

Cuando se invoquen los métodos de clase no se tiene que proporcionar la keyword self, ya que lo maneja Python automáticamente en tiempo de ejecución.

Cuando se nombra un método como: __init__, no será un método regular, será un constructorS.

Si una clase tiene un constructor, este se invoca automática e implícitamente cuando se instancia el objeto de la clase.

Para crear un objeto usamos:

nombre_objeto = nombreClase()

Cada clase de Python y cada objeto de Python está pre-equipado con un conjunto de atributos útiles que pueden usarse para examinar sus capacidades.

Los objetos de Python, cuando se crean, están dotados de un pequeño conjunto de propiedades y métodos predefinidos.

Cada objeto los tiene, los quieras o no. Uno de ellos es una variable llamada __dict__ (es un diccionario).

class Clase: atributo = 1 def __init__(self): self.atributo = 2 def metodo(self): pass def __oculto(self): pass obj = Clase() print(obj.__dict__) print(Clase.__dict__)

__dict__ es un diccionario.

La propiedad __name__ contiene el nombre de la clase, es solo una cadena y está ausente del objeto, es decir, existe solo dentro de las clases.

__module__ es una cadena y almacena el nombre del módulo que contiene la definición de la clase.

Cualquier módulo llamado __main__ en realidad no es un módulo, sino es el archivo actualmente en ejecución.

__bases__ es una tupla. La tupla contiene clases (no nombres de clases) que son superclases directas para la clase.

class Padre1: pass class Padre2: pass def printbases(cls): print('( ', end='') for x in cls.__bases__: print(x.__name__, end=' ') print(')') class Subclase(Padre1, Padre2): varClase = 1 def accion(self): print(self.varClase + self.varClase) print(Subclase.__name__) print(Subclase.__module__) obj = Subclase() print(type(obj).__name__) print(obj.__module__) printbases(Padre1) printbases(Padre2) printbases(Subclase)

Introspección capacidad de un programa para examinar el tipo o las propiedades de un objeto en tiempo de ejecución.

Reflexión capacidad de un programa para manipular los valores, propiedades y/o funciones de un objeto en tiempo de ejecución

class Clase: pass obj = Clase() obj.a = 1 obj.b = 2 obj.i = 3 obj.ireal = 3.5 obj.entero = 4 obj.z = 5 def examina(obj): for name in obj.__dict__.keys(): if name.startswith('i'): val = getattr(obj, name) if isinstance(val, int): setattr(obj, name, val + 1) print(obj.__dict__) examina(obj) print(obj.__dict__)

Ejemplo de una clase:

class saludo(): # Método 1 def saludo(self, idioma): if(idioma == "en"): print("Hello world") elif(idioma == "it"): print("Ciao mondo") else: #default print("Hola mundo") # Método 2 def castellano(self): print("Hola mundo") # Método 3 def italiano(self): print("Ciao mondo") def ingles(self): print("Hello world") def init(): oSaludo = saludo() oSaludo.ingles() oSaludo.italiano() oSaludo.castellano() oSaludo.saludo("") oSaludo.saludo("it") oSaludo.saludo("en") if __name__ == "__main__": init()

Constructor

El constructor es un método que se llama cuando se crea un objeto.

Este método se define en la clase y se puede utilizar para inicializar variables básicas.

La operación de instanciación ("invocar" a un objeto de clase) crea un objeto vacío.

A muchas clases les gusta crear objetos con instancias personalizadas para un estado inicial específico.

Por lo tanto, una clase puede definir un método especial llamado __init __().

Considere lo siguiente:

• El nombre del constructor es siempre __init__().
• Tiene que tener al menos un parámetro obligatorio, generalmente se denomina self.
  El parámetro se usa para representar el objeto recién creado: puedes usar el parámetro para manipular el objeto y enriquecerlo con las propiedades necesarias.

Cuando una clase define un método __init __(), la instanciación de clase invoca automáticamente __init __() para la instancia de clase recién creada.

Un constructor se puede utilizar para configurar el objeto, es decir, inicializa adecuadamente su estado interno, crea variables de instancia, crea instancias de cualquier otro objeto si es necesario, etc.

Un constructor no devuelve un valor, esta diseñado para devolver un objeto recién creado.

Un constructor No se puede invocar directamente desde el objeto o desde dentro de la clase. Es posible invorcar un constructor desde cualquiera de las superclases (las más generales) del objeto.

Objeto

Cada vez que se describe un objeto y se usa:

Un sustantivo: probablemente se este definiendo el nombre del objeto.

Un adjetivo: probablemente se este definiendo una propiedad del objeto.

Un verbo: probablemente se este definiendo una actividad del objeto.

Spirit es un corcel indomable y salvaje que corre por la pradrera.

• Nombre del objeto = Spirit
• Clase de inicio = Corcel mustang
• Propiedad = Temperamento (indomable y salvaje)
• Actividad = Correr (por la pradrera)

Una Motocileta negra de competencia.

• Nombre del objeto = Motocicleta
• Clase de inicio = Vehículo terrestre
• Propiedad = Color (negra)
• Actividad = Tipo (competencia)

La programación orientada a objetos es el arte de definir y expandir clases. Una clase es un modelo de una parte muy específica de la realidad, que refleja las propiedades y actividades que se encuentran en el mundo real.

El proceso no necesita tener un final. Puedes crear tantas clases como necesites.

La clase que se define no tiene nada que ver con el objeto: la existencia de una clase no significa que ninguno de los objetos compatibles se creará automáticamente. La clase en sí misma no puede crear un objeto: debes crearlo tu mismo y Python te permite hacerlo.

Encapsulamiento

La capacidad de ocultar (proteger) los valores seleccionados contra el acceso no autorizado se llama encapsulamiento; no se puede acceder a los valores encapsulados ni modificarlos si deseas utilizarlos exclusivamente.

Variables privadas

Las variables de instancia "privadas" a las que no se puede acceder excepto desde el interior de un objeto no existen en Python.

Sin embargo, existe una convención que es seguida por la mayoría del código Python: un nombre prefijado con un guión bajo debe tratarse como una parte no pública, es decir, privada de la API: ya sea una función, método o un miembro de datos.

Debe considerarse un detalle de implementación y sujeto a cambios sin previo aviso.

class Pila: def __init__(self): self.__listaPila = [] def push(self, val): self.__listaPila.append(val) def pop(self): val = self.__listaPila[-1] del self.__listaPila[-1] return val objetoPila = Pila() objetoPila.push(3) objetoPila.push(2) objetoPila.push(1) print(objetoPila.pop()) print(objetoPila.pop()) print(objetoPila.pop())

Fuente: Networking Academy - Python Institute - PCAP - Programming Essentials in Python Español 0321a cga

Variables de clase e instancia

En términos generales, las variables de instancia son para datos únicos para cada instancia.

Las variables de clase son para atributos y métodos compartidos por todas las instancias de la clase.

Una variable de clase es una propiedad que existe en una sola copia y se almacena fuera de cualquier objeto.

Las variables de clase no se muestran en el diccionario de un objeto __dict__ esto es natural ya que las variables de clase no son partes de un objeto.

Una variable de clase siempre presenta el mismo valor en todas las instancias de clase (objetos).

Las variables de clase existen incluso cuando no se creó ninguna instancia de clase (objeto).

class Dog: kind = 'canine' # class variable shared by all instances def __init__(self, name): self.name = name # instance variable unique to each instance d = Dog('Fido') e = Dog('Buddy') print(d.kind) # shared by all dogs: 'canine' print(e.kind) # shared by all dogs: 'canine' print(d.name) # unique to d: 'Fido' print(e.name) # unique to e: 'Buddy'

Cuando una clase esta basada en una superclase de la que estaba heredando, se coloca el nombre de esa otra clase dentro de estos paréntesis.

Herencia es pasar atributos y métodos de la superclase a una clase recién creada, llamada subclase.

Es posible construir clases más especializadas (más concretas, las subclases).

La herencia múltiple ocurre cuando una clase tiene más de una superclase. Python busca una entidad de abajo hacia arriba.

Python busca componentes de objetos en el siguiente orden:

• Dentro del objeto mismo.
• En sus superclases, de abajo hacia arriba.
• Si hay más de una clase en una ruta de herencia, Python busca de izquierda a derecha.

class motocicleta(): # Método 1 def color(self, c): print("El color de la moto es: ", c) # Método 2 def cilindrada(self, cc): print("La cilindrada es: ", cc) # Método 3 def marca(self, trade): print("La marca es: ", trade) class motocross(motocicleta): # Método 1 def uso(self): print("Para uso en todo terreno") # Método 2 def especialidad(self): print("Especial para competencia") def init(): moto = motocicleta() moto.marca("KTM") moto.color("Rojo") moto.cilindrada(390) cross = motocross() #característica heredada cross.marca("KTM") #característica heredada cross.color("Rojo") #característica heredada cross.cilindrada(390) #característica heredada cross.uso() cross.especialidad() if __name__ == "__main__": init()

Identificador de objeto interno utilizado por Python

class Motocicleta: def __init__(self, marca, modelo): self.marca = marca self.modelo = modelo moto = Motocicleta("Aprilia ", "RSV 1000 R") print(moto) # <__main__.Motocicleta object at 0x000001F5DCC02DC0>

Salida más cordial para el usuario:

class Motocicleta: def __init__(self, marca, modelo): self.marca = marca self.modelo = modelo def __str__(self): return self.marca + ' en la ' + self.modelo moto = Motocicleta("Aprilia ", "RSV 1000 R") print(moto) # Aprilia en la RSV 1000 R

issubclass()

Si B es una subclase de A y
C es una subclase de B, esto también significa que C es una subclase de A, ya que la relación es totalmente transitiva.

Para comprobar la herencia de la clase

issubclass(bool, int) es True ya que bool es una subclase de int.

Sin embargo, issubclass(float, int) es False ya que float no es una subclase de int.

Cada clase se considera una subclase de sí misma.

class Vehiculo: pass class VehiculoTerrestre(Vehiculo): pass class VehiculoMoto(VehiculoTerrestre): pass oB = VehiculoTerrestre() oC = VehiculoMoto() print(issubclass(VehiculoTerrestre, Vehiculo)) # True print(issubclass(VehiculoMoto, Vehiculo)) # True print(issubclass(Vehiculo, Vehiculo)) # True

isinstance()

Se emplea para verificar el tipo de una instancia:

isinstance(obj, int) será True solo si obj.__ class__ es int o alguna clase derivada de int.

Es cuando la subclase puede modificar el comportamiento de su superclase.

class Vehiculo: def x(self): print("comportamiento base: tiene llantas") def y(self): self.x() class Motocicleta(Vehiculo): # Hereda de A def x(self): print("polimorfismo: tiene 2, 3 o 4 llantas") v = Vehiculo() m = Motocicleta() v.y() # comportamiento base: tiene llantas m.y() # polimorfismo: tiene 2, 3 o 4 llantas

La herencia extiende las capacidades de una clase agregando nuevos componentes y modificando los existentes.

La composición proyecta una clase como contenedor capaz de almacenar y usar otros objetos (derivados de otras clases) donde cada uno de los objetos implementa una parte del comportamiento de una clase.

Divide una pieza de software en partes separadas pero cooperantes.

Los módulos, junto con las funciones integradas, forman la Biblioteca estándar de Python

Cada módulo consta de entidades. Estas entidades pueden ser funciones, variables, constantes, clases y objetos.

Módulo math.

Módulos en Python son archivos escritos en Python y almacenados con la extensión .py
La instalación estándar de Python contiene bastantes módulos pero puedes ampliar su biblioteca.

De esta manera podemos ir creando nuestro propio código reutilizable en diferentes proyectos, sin la necesidad de estar copiando código.

Para que un módulo sea utilizable, hay que importarlo, empleando la sentencia import. En otros lenguajes seria un use.

import math print(math.sqrt(64)) print(math.pi)

La instrucción import puede colocarse en cualquier parte del código, pero debe colocarse antes del primer uso de cualquiera de las entidades del módulo.

Si se desea importar más de un módulo, se puede hacer repitiendo la cláusula import, o listando los módulos despues de la palabra reservada import, y separando el nombre de cada módulo con una coma (,)

Para acceder a la entidad de un módulo se utiliza la notación de punto:

math.pi

__pycache__

Cuando creamos modulos y los importamos se crea un directorio llamado __pycache__ y un archivo, por ejemplo:

<nombre_modulo>.cpython-39.pyc.

Donde los digitos corresponden versión de Python y la ultima parte (pyc) viene de las palabras Python y compilado.

Cuando Python importa un módulo por primera vez, traduce el contenido a una forma "semi" compilada.

El archivo no contiene código en lenguaje máquina: es código semi-compilado interno de Python, listo para ser ejecutado por el intérprete de Python.

Como tal archivo no requiere tantas comprobaciones como las de un archivo fuente, la ejecución comienza más rápido y también se ejecuta más rápido.

Python puede verificar si el archivo fuente del módulo ha sido modificado (en este caso, el archivo pyc será reconstruido) o no (cuando el archivo pyc pueda ser ejecutado al instante). Este proceso es completamente automático y transparente, no se tiene que estar tomando en cuenta.

__name__

También crea una variable llamada __name__.

Con tan solo hacer el import del módulo creado, se ejecuta como una extensión del programa desde el cual se importa, por ejemplo si el modulo solo tiene una línea que es un print("Hola módulo", al ejecutar el programa aparecerá dicho mensaje.

Archivo que importa el módulo:

import mimodulo

Módulo creado:

print("Hola módulo", __name__)

Salida de la ejecución del archivo que importa el módulo:

Hola módulo mimodulo



Archivo que importa el módulo:

import mimodulo if __name__ == "__main__": print("soy el programa que invoca el módulo") else: print("no soy main")

Módulo creado:

print("Hola módulo", __name__) if __name__ == "__main__": print("no soy main") else: print("soy módulo")

Salida de la ejecución del archivo que importa el módulo:

Hola módulo mimodulo
soy módulo
soy el programa que invoca el módulo

Se debe tener en mente que el módulo solo existe en un archivo independiente, pero al importar el módulo es una extensión del código por lo que, si se declara una variable en el módulo, el programa que importa, puede acceder a la variable anteponiendo el nombre del módulo y usando la notación de punto.

mimodulo.variable

A diferencia de muchos otros lenguajes de programación, Python no tiene medios para permitirte ocultar tales variables a los ojos de los usuarios del módulo.

Solo puedes informar a tus usuarios que esta es tu variable, que pueden leerla, pero que no deben modificarla bajo ninguna circunstancia. Esto se hace anteponiendo al nombre de la variable _ (un guión bajo) o __ (dos guiones bajos), pero recuerda, es solo un acuerdo. Los usuarios de tu módulo pueden obedecerlo o no. Python como se menciono no puede impedir que se altere la variable fuera del módulo.

path

¿Qué sucede cuando el archivo que invoca a un módulo se encuentra en otro directorio?

Hay una variable especial (en realidad una lista) que almacena todas las ubicaciones (carpetas o directorios) que se buscan para encontrar un módulo que ha sido solicitado por la instrucción import.

Python examina estas carpetas en el orden en que aparecen en la lista: si el módulo no se puede encontrar en ninguno de estos directorios, la importación falla.

De lo contrario, se tomará en cuenta la primera carpeta que contenga un módulo con el nombre deseado (si alguna de las carpetas restantes contiene un módulo con ese nombre, se ignorará).

La variable se llama path (ruta), y es accesible a través del módulo llamado sys.

Si hay un archivo zip listado como uno de los elementos de la ruta, Python puede tratar los archivos zip como carpetas ordinarias, esto puede ahorrar mucho almacenamiento.

Una solución podría ser:

from sys import path path.append("..\\mods") # or insert() import mimodulo

__init__.py

Los paquetes, como los módulos, pueden requerir inicialización.

La inicialización de un módulo se realiza mediante un código independiente (que no forma parte de ninguna función) ubicado dentro del archivo del módulo. Como un paquete no es un archivo, esta técnica es inútil para inicializar paquetes.

En su lugar, debes usar un truco diferente: Python espera que haya un archivo con un nombre muy exclusivo dentro de la carpeta del paquete: __init__.py.

El contenido del archivo se ejecuta cuando se importa cualquiera de los módulos del paquete.

Si no deseas ninguna inicialización especial, se puede dejar el archivo vacío, pero no se debe omitir.

from

Existe una forma más óptima de importar un módulo y sus entidades:

from math import pi

Lo cual expresa que solo se importe esa parte del módulo y no el módulo completo.

De la misma manera que se pueden importar varios módulos, se pueden usar varias entidades de un módulo:

from math import pi, sin

Para importar todo:

from module import *

Para usar un alias

import math as m

from module import nombre as alias

from module import n as a, m as b, o as c

dir()

La función devuelve una lista ordenada alfabéticamente la cual contiene todos los nombres de las entidades disponibles en el módulo:

namespace

Un namespace es un espacio en el que existen algunos nombres y los nombres no entran en conflicto entre sí (es decir, no hay dos objetos diferentes con el mismo nombre).

El grupo tiende a nombrar a cada uno de sus miembros de una manera única.

Dentro de un determinado namespace, cada nombre debe permanecer único.

Para obtener cierta funcionalidad que Python proporciona se debe indicar a Python dónde obtenerla especificamente, esto con el uso de la keyword from.

from datetime import date

Un generador de números aleatorios toma un valor llamado semilla, lo trata como un valor de entrada, calcula un número "aleatorio" basado en él (el método depende de un algoritmo elegido) y produce una nueva semilla.

La duración de un ciclo en el que todos los valores semilla son únicos puede ser muy largo, pero no es infinito: tarde o temprano los valores iniciales comenzarán a repetirse y los valores generadores también se repetirán. Esto es normal. Es una característica, no un error.

El valor de la semilla inicial, establecido durante el inicio del programa, determina el orden en que aparecerán los valores generados.

El factor aleatorio del proceso puede ser aumentado al establecer la semilla tomando un número de la hora actual - esto puede garantizar que cada lanzamiento del programa comience desde un valor semilla diferente (por lo tanto, usará diferentes números aleatorios).

Afortunadamente, Python realiza dicha inicialización al importar el módulo.

from random import random for i in range(5): print(random())

El módulo cuenta con algunas funciones:

from random import randrange, randint print(randrange(1)) print(randrange(0, 1)) print(randrange(0, 1, 1)) print(randint(0, 1))

random.seed(a=None, version=2)

Inicializa el generador de números aleatorios.

Si se omite a o None, se utiliza la hora actual del sistema.

Si el sistema operativo proporciona las fuentes de aleatoriedad, se utilizan en lugar de la hora del sistema.

Si a es un int, se usa directamente.

Es capaz de establecer la semilla del generador.

from random import random, seed print(random()) print(random()) print("---") mismoValor = 2 seed(mismoValor) # establece la semilla con la hora actual. print(random()) # <-- seed(mismoValor) # establece la semilla con el valor entero del argumento. print(random()) # <-- seed(mismoValor + 1) # establece la semilla con el valor entero del argumento. print(random()) seed(mismoValor + 2) # establece la semilla con el valor entero del argumento. print(random())

random.randint(a, b)

Devuelve un entero aleatorio N tal que a <= N <= b.

from random import randint rango = 5 for r in range(rango): print(randint(1, rango), end=',') # Duplicados print() for r in range(rango): print(randint(1, rango), end=',') # Duplicados

Las niveles son:

Las capas son:

• El código (en ejecución) se encuentra en la parte superior.
• El entorno de ejecución de Python se encuentra directamente debajo de él.
• La siguiente capa de la pirámide se llena con el SO (sistema operativo): el entorno de Python proporciona algunas de sus funcionalidades utilizando los servicios del sistema operativo. Python, aunque es muy potente, no es omnipotente: se ve obligado a usar muchos ayudantes si va a procesar archivos o comunicarse con dispositivos físicos.
• La capa más inferior es el hardware: el procesador (o procesadores), las interfaces de red, los dispositivos de interfaz humana (ratones, teclados, etc.) y toda otra maquinaria necesaria para hacer funcionar la computadora: el sistema operativo sabe cómo emplearlos y utiliza muchos trucos para trabajar con todas las partes en un ritmo constante.

¿Qué sucede para que se ejecute el código?

• El código quiere crear un archivo, por lo que invoca una de las funciones de Python.
• Python acepta la orden, la reorganiza para cumplir con los requisitos del sistema operativo local (es como poner el sello "aprobado" en una solicitud) y lo envía.
• El SO comprueba si la solicitud es razonable y válida (por ejemplo, si el nombre del archivo se ajusta a algunas reglas de sintaxis) e intenta crear el archivo. Tal operación, aparentemente es muy simple, no es atómica: consiste de muchos pasos menores tomados por...
• El hardware, el cual es responsable de activar los dispositivos de almacenamiento (disco duro, dispositivos de estado sólido, etc.) para satisfacer las necesidades del sistema operativo.

El módulo platform permite acceder a los datos de la plataforma subyacente, es decir, hardware, sistema operativo e información sobre la versión del intérprete.

Existe también una función que puede mostrar todas las capas subyacentes en un solo vistazo, llamada platform.

Simplemente devuelve una cadena que describe el entorno; por lo tanto, su salida está más dirigida a los humanos que al procesamiento automatizado.

machine() devuelve el nombre genérico del procesador.

processor() devuelve el nombre real del procesador.

system() devuelve el nombre genérico del sistema operativo.

version devuelve la versión del sistema operativo. python_implementation() y python_version_tuple() devuelven la versión de Python está ejecutando y el número de versión respectivamente.

from platform import system print(system()) from platform import version print(version()) from platform import machine print(machine()) from platform import processor print(processor()) from platform import platform print(platform()) from platform import python_implementation, python_version_tuple print(python_implementation()) for atr in python_version_tuple(): print(atr, end=" ")

Existe una jerarquía entre:

• package
  • module
    • function

Un módulo es un contenedor lleno de funciones - puedes empaquetar tantas funciones como desees en un módulo y distribuirlo.

Un paquetes puede agrupar modulos.

Al escribir programas de estilo funcional, a menudo necesitará pequeñas funciones que actúen como predicados o que combinen elementos de alguna manera.

Si la función que necesita no existe, debe escribirla.

Una forma de escribir funciones pequeñas es usar la expresión lambda.

lambda toma varios parámetros y una expresión que combina estos parámetros y crea una función anónima que: devuelve el valor de la expresión:

El siguiente código sirva para ejemplificar, sin embargo no es del todo correcto, PEP 8 indica que:

"no asigne una expresión lambda, use def".

x = lambda: 2 print("x ya no es ánonima:", x()) # Se puede usar su nombre para invocar la función suma = lambda a: a + a print("Función lambda de un parámetro:", suma(4)) saludo = lambda s1, s2: s1 + '' + s2 print("Función lambda con 2 parámetros:", saludo("Hola", "mundo!"))

Expresiones lambda

Se pueden crear pequeñas funciones anónimas con la palabra clave lambda.

Esta función devuelve la suma de sus dos argumentos: lambda a, b: a + b.

Las funciones Lambda se pueden utilizar siempre que se requieran objetos de función.

Están restringidos sintácticamente a una sola expresión.

Semánticamente, son simplemente azúcar sintáctico para una definición de función normal.

Utilidad

La utilidad de una función lambda es escribir partes anónimas de código destinadas a evaluar un resultado.

Para el manejo de fechas se debe indicar al intérprete de Python que desde el módulo estándar de fecha y hora que viene con la biblioteca estándar, se importen las clases de fecha, hora y fecha y hora.

from datetime import date from datetime import time from datetime import datetime def init(): print(date.today()) #Método print(date.today().day) #Propiedad print(date.today().month) #Propiedad print(date.today().year) #Propiedad print(date.today().weekday()) #Método (6 es Domingo, 2 es Miércoles) diaSemana = ["Lunes", "Martes", "Miércoles", "Jueves", "Viernes", "Sábado", "Domingo"] print("Hoy es: ", diaSemana[date.today().weekday()]) print("Fecha y hora actual: ", datetime.now()) print("La hora es: ", datetime.time(datetime.now())) print(datetime.now().strftime("El año actual es: %Y")) print(datetime.now().strftime("%a, %d %B, %y")) print(datetime.now().strftime("Fecha y hora local: %c")) print(datetime.now().strftime("Fecha local: %x")) print(datetime.now().strftime("Hora local: %X")) print(datetime.now().strftime("Hora: %I:%M:%S %p")) print(datetime.now().strftime("24 Horas: %H:%M:%S %p")) # %p AM/PM print(datetime.now().strftime("Hora: %I:%M")) if __name__ == "__main__": init();

Un objeto timedelta representa una duración, la diferencia entre dos fechas u horas.

from datetime import timedelta from datetime import date from datetime import time from datetime import datetime # print(timedelta(days=365, hours=21, minutes=10)) print("Fecha y hora actual: ", datetime.now()) print("Un dia a partir de ahora: ", datetime.now() + timedelta(hours=24) ) print("Un semana a partir de ahora: ", datetime.now() + timedelta(weeks=1) ) print("Un año a partir de ahora: ", datetime.now() + timedelta(days=365) ) # print( ( datetime.now() - timedelta(hours=24) ).strftime("Hace 24 horas: %A %B %d, %Y") ) print( ( datetime.now() - timedelta(weeks=1) ).strftime("Hace 1 semana: %A %B %d, %Y") ) print( ( datetime.now() - timedelta(days=365) ).strftime("Hace 365 días: %A %B %d, %Y") ) # def calculaTiempo(dia, mes): hoy = date.today() fecha = date(hoy.year, mes, dia) # Fecha de calculo if fecha < hoy: print ("fue hace %d días" % ((hoy - fecha).days)) fecha = fecha.replace(year = hoy.year + 1) # Obtener la fecha para el próximo año faltan = fecha - hoy print ("Faltan ", faltan.days, " para esa fecha") #Fin de calculaTiempo print("\nCuanto falta para el 24 de diciembre: ") calculaTiempo(24, 12)

La diferncia entre time y timedelta es el formato que manejan, donde timedelta pudiera resultar más entendible para una persona, el estar su formato expresado en horas, minutos, segundos y milisegundos:

Este módulo permite generar calendarios y proporciona funciones útiles relacionadas con el calendario.

De forma predeterminada, estos calendarios tienen el lunes como primer día de la semana y el domingo como último (la convención europea).

Utilice setfirstweekday() para establecer el primer día de la semana en domingo (6) o en cualquier otro día de la semana.

Los parámetros que especifican fechas se dan como números enteros.

Las funciones y clases definidas en este módulo utilizan un calendario idealizado, el actual calendario gregoriano extendido indefinidamente en ambas direcciones.
Esto coincide con la definición del calendario "gregoriano proléptico" en el libro "Calendrical Calculations" de Dershowitz y Reingold, donde es el calendario base para todos los cálculos.

Los años cero y negativos se interpretan según lo prescrito por la norma ISO 8601. El año 0 es 1 AC, el año -1 es 2 AC, y así sucesivamente.

import calendar calendario = calendar.TextCalendar(calendar.MONDAY) tiempo = calendario.formatmonth(2020, 1, 0, 0) print(tiempo) # Formato HTML print(calendar.HTMLCalendar(calendar.MONDAY).formatmonth(2020, 10)) print("\nIterador del número de día") for nDia in calendario.itermonthdays(2020,10): print(nDia) # Donde los ceros al inicio y al final pertenecen a otros meses print("\nIterador de meses") for mes in calendar.month_name: print(mes) print("\nIterador de días") for dia in calendar.day_name: print(dia) print("\nCalendarizar evento: viernes de cada mes") for m in range(1,13): # Iterar todos los meses, recuerde que 13 no es inclusivo en el rango calendarizar = calendar.monthcalendar(2020, m) semana1 = calendarizar[0] semana2 = calendarizar[1] if semana1[calendar.FRIDAY] != 0: evento = semana1[calendar.FRIDAY] else: evento = semana2[calendar.FRIDAY] print("%10s %2d" % (calendar.month_name[m], evento))

open()

Podemos acceder a un archivo a través de la función open(filename, mode) la cual regresa un objeto de tipo file, esta función tiene 2 argumentos, el primero indica el archivo a trabajar y el segundo el modo de acceso a este.

1. El primer parámetro filename de la función especifica el nombre del archivo que se asociará al stream.


2. El segundo parámetro mode especifica el modo de apertura utilizado para el stream; es una cadena llena de una secuencia de caracteres, y cada uno de ellos tiene su propio significado especial.
   
   • r solo lectura.
     El archivo asociado con el stream debe existir y tiene que ser legible, de lo contrario la función open() lanzará una excepción.
   • w solo escritura
     El archivo asociado con el stream no necesita existir.
     Si no existe, se creará;
     Si existe un archivo con el mismo nombre, podría ser eliminado. Si existe, se truncará a la longitud de cero (se borrá);
     Si la creación no es posible por ejemplo, debido a los permisos del sistema, la función open() lanzará una excepción.
   • a se abre para agregar contenido.
     El archivo asociado con el stream no necesita existir;
     Si no existe, se creará;
     Si existe, el cabezal de grabación virtual se establecerá al final del archivo y el contenido anterior del archivo permanece intacto.
     Cualquier dato agregado al archivo será agregado en automático al final.
   • r+ lectura y escritura
     Se abre el archivo tanto en modo lectura como escritura.
     El argumento de modo de acceso es opcional.
     El archivo asociado con el stream no necesita existir;
     Si no existe, se creará;
     Si existe, el contenido anterior del archivo permanece intacto.
   
   Nota: r por defecto si el modo de acceso es omitido su modo es de lectura. También puedes abrir un archivo para su creación exclusiva. Puedes hacer esto usando el modo de apertura x. Si el archivo ya existe, la función open() lanzará una excepción.


3. El tercer parámetro opcional encoding especifica el tipo de codificación, por ejemplo, UTF-8 cuando se trabaja con archivos de texto.

Si la apertura es exitosa, la función devuelve un objeto stream; de lo contrario, se genera una excepción (por ejemplo, FileNotFoundError si el archivo que vas a leer no existe).

os

os este módulo proporciona una forma portátil de utilizar la funcionalidad dependiente del sistema operativo. Si desea manipular rutas, vea el módulo os.path

import os from os import path import datetime from datetime import date, time, timedelta import time # def main(): print("Sistema operativo: ", os.name) print("¿El archivo existe?: ", path.exists("file1.txt")) f = "27-10-2020_0_28_156335.log" print("¿El archivo existe?: ", path.exists(f)) o = "c:\\Windows" print("¿Es un archivo?: ", path.isfile(o)) print("¿Es un archivo?: ", path.isfile(f)) print("¿Es un directorio?: ", path.isdir(o)) print("¿Es un directorio?: ", path.isdir(f)) print("Ubicación: ", path.realpath(f)) ubicacionReal = path.realpath(f) print("Ubicación y nombre: ", path.split(ubicacionReal)) fechaMod = path.getmtime(f) modificado = time.ctime(fechaMod) print("El archivo se modifico:", modificado) mod = datetime.datetime.fromtimestamp(fechaMod) print("El archivo se modifico:", mod) ahora = datetime.datetime.now() lapsoModificado = ahora - mod print("Tiempo transcurrido desde su modificación: ", lapsoModificado) print("Segundos transcurridos desde su modificación: ", lapsoModificado.total_seconds()) if __name__ == "__main__": main()

FileNotFoundError

Se genera cuando se solicita un archivo o directorio, pero no existe. Corresponde a errno ENOENT.

import os from os import path f = "ejemplo.log" print("1. Abrir archivo...") try: f = open(f, "r") except FileNotFoundError: print("Ocurrio una excepción: FileNotFoundError: [Errno 2] No such file or directory") print("2. Leer archivo...") print("3. Cerrar archivo...")

close

Si un archivo es abierto, este debe ser cerrado con el método close(), después de acceder a su modo.

Ejemplo, validar si el archivo existe, entonces mostrar su contenido, en caso contrario mostrar que no existe el archivo.

import os from os import path f = "27-10-2020_0_28_156335.log" if path.exists(f): #Si el archivo existe imprimir contenido f = open(f, "r") print(f.read()) f.close() else: print("El archivo no existe")

El siguiente ejemplo intenta abrir un archivo pero si no existe este, entonces lo crea:

def ahora(): return str(datetime.now().day) + "-" + str(datetime.now().month) + "-" + str(datetime.now().year) + "_" + str(datetime.now().hour) + "_" + str(datetime.now().minute) + "_" + str(datetime.now().microsecond) from datetime import datetime nombreArchivo = ahora() print ("Nombre del archivo es: ", nombreArchivo) archivo = open(nombreArchivo + ".log", "w") # Si el archivo no existe, lo crea. archivo.close()

write

El método write() espera solo un argumento: una cadena que se transferirá a un archivo abierto, el modo de apertura debe reflejar la forma en que se transfieren los datos (escribir en un archivo abierto en modo de lectura no tendrá éxito).

No se agrega carácter de nueva línea al argumento de write(), por lo que debe agregar si se desea que el archivo se complete con varias líneas.

El siguiente ejemplo creará el mismo archivo con el mismo contenido cada que se ejecute el programa:

from os import strerror try: fo = open('archivo_ch.txt', 'wt') # un nuevo archivo (newtext.txt) es creado for i in range(10): s = "línea #" + str(i + 1) + "\n" for ch in s: fo.write(ch) fo.close() except IOError as e: print("Se produjo un error de E/S: ", strerror(e.errno)) print("Version 2 escribe linea por linea") try: fo = open('archivo_ln.txt', 'wt') for i in range(10): fo.write("line #" + str(i + 1) + "\n") fo.close() except IOError as e: print("Se produjo un error de E/S: ", strerror(e.errno))

Para escribir en el archivo se usa el método write(contenido), ejemplo que crea un archivo diferente cada vez que se ejecuta el programa:

def ahora(): return str(datetime.now().day) + "-" + str(datetime.now().month) + "-" + str(datetime.now().year) + "_" + str(datetime.now().hour) + "_" + str(datetime.now().minute) + "_" + str(datetime.now().microsecond) from datetime import datetime nombreArchivo = ahora() print ("Nombre del archivo es: ", nombreArchivo) archivo = open(nombreArchivo + ".log", "w") # Si el archivo no existe, lo crea. for texto in range(3): archivo.write(ahora() + "\n") # n es new line archivo.close()

Streams pre-abiertos

Cualquier operación del stream debe estar precedida por la invocación de la función open().

Hay tres excepciones bien definidas a esta regla: sys.stdin, sys.stdout y sys.stderr.

Cuando comienza nuestro programa, los tres streams ya están abiertos y no requieren ninguna preparación adicional.

sys.stdin

Entrada estándar. Se utiliza para todas las entradas interactivas (incluidas las llamadas a input ());

El stream stdin normalmente se asocia con el teclado, se abre previamente para la lectura y se considera como la fuente de datos principal para los programas en ejecución.

La función bien conocida input() lee datos de stdin por default.

sys.stdout

Salida estándar. Se usa para la salida de print() y declaraciones de expresión y para las solicitudes de input();

El stream stdout normalmente está asociado con la pantalla, preabierta para escritura, considerada como el objetivo principal para la salida de datos por el programa en ejecución.

La función bien conocida print() envía los datos al stream stdout.

sys.stderr

Salida de error estándar. Las propias indicaciones del intérprete y sus mensajes de error van a stderr.

El stream stderr normalmente está asociado con la pantalla, preabierta para escribir, considerada como el lugar principal donde el programa en ejecución debe enviar información sobre los errores encontrados durante su trabajo.

La separación de stdout resultados útiles producidos por el programa de stderr (mensajes de error, indudablemente útiles pero no proporcionan resultados) ofrece la posibilidad de redirigir estos dos tipos de información a los diferentes objetivos.

stream.close()

La última operación realizada en un stream (esto no incluye a los streams stdin, stdout, y stderr pues no lo requieren) debe ser cerrarlo.

Esa acción se realiza mediante un método invocado desde dentro del objeto del stream: stream.close().

• La función no espera argumentos; el stream no necesita estar abierto.
• La función no devuelve nada pero lanza una excepción IOError en caso de un error.
• Considera que close() puede fallar.

Errores con streams

El objeto IOError está equipado con una propiedad llamada errno (el nombre viene de la frase error number, número de error).

El valor del atributo errno se puede comparar con una de las constantes simbólicas predefinidas en módulo errno.

• errno.EACCES. Permiso denegado
• errno.EBADF. Número de archivo incorrecto
• errno.EEXIST. Archivo existente
• errno.EFBIG. Archivo demasiado grande
• errno.EISDIR. Es un directorio
• errno.EMFILE. Demasiados archivos abiertos
• errno.ENOENT. El archivo o directorio no existe
• errno.ENOSPC. No queda espacio en el dispositivo

https://docs.python.org/es/3/library/errno.html

https://docs.python.org/3/library/errno.html

strerror()

Devuelve el mensaje de error correspondiente al código de error en el código.

En plataformas donde strerror() devuelve NULL cuando se le da un número de error desconocido, se genera ValueError.

f = "ejemplo.log" try: f = open(f, "r") except Exception as exc: print("(errno) El archivo no se pudo abrir:", strerror(exc.errno))

Ejemplo de lectura de un archivo con strerror():

from os import strerror try: stream = open("archivo.txt", "rt", encoding="utf-8") print(stream.read()) except Exception as exc: print("(errno) El archivo no se pudo abrir:", strerror(exc.errno))

Ejemplo de lectura de los caracteres que tiene de un archivo con strerror():

from os import strerror try: cnt = 0 s = open('archivo.txt', "rt") ch = s.read(1) while ch != '': print(ch, end='') cnt += 1 ch = s.read(1) s.close() print("\n\nCaracteres en el archivo: ", cnt) except IOError as e: print("Se produjo un error de E/S: ", strerror(e.errno))

mode

Podemos conocer el modo de acceso del archivo con la propiedad mode.

read

Para obtener el contenido del archivo se usa el método read()

Para obtener todo el contenido del archivo por líneas se usa el método readlines().

tell

El método tell() devuelve un número entero que da la posición actual del objeto de archivo en el archivo representado como el número de bytes desde el principio del archivo cuando está en modo binario y un número opaco cuando está en modo texto.

readline

El método readline() lee solamente una línea del archivo.

El método intenta leer una línea completa de texto del archivo, y la devuelve como una cadena en caso de éxito. De lo contrario, devuelve una cadena vacía.

Ejemplo de lectura de los caracteres y líneas que tiene de un archivo con readline() strerror():

from os import strerror try: ccnt = lcnt = 0 s = open('archivo.txt', 'rt') line = s.readline() while line != '': lcnt += 1 for ch in line: print(ch, end='') ccnt += 1 line = s.readline() s.close() print("\n\nCaracteres en el archivo: ", ccnt) print("Lineas en el archivo: ", lcnt) except IOError as e: print("Se produjo un error de E/S: ", strerror(e.errno))

Para cambiar la posición del objeto de archivo, se usa el método seek(desplazamiento, de dónde). La posición se calcula sumando el desplazamiento a un punto de referencia; el punto de referencia se selecciona mediante el argumento de origen. Un valor de donde 0 mide desde el principio del archivo, 1 usa la posición actual del archivo y 2 usa el final del archivo como punto de referencia. donde se puede omitir y el valor predeterminado es 0, utilizando el comienzo del archivo como punto de referencia.

readlines

Cuando el método readlines(), se invoca sin argumentos, intenta leer todo el contenido del archivo y devuelve una lista de cadenas, un elemento por línea del archivo.

Si no estás seguro de si el tamaño del archivo es lo suficientemente pequeño y no deseas probar el sistema operativo, puede indicar al método readlines() de leer no más de un número especificado de bytes a la vez.

El tamaño máximo del búfer de entrada aceptado se pasa al método como argumento.

Ejemplo de lectura de los caracteres y líneas que tiene de un archivo con readlines() strerror():

from os import strerror try: ccnt = lcnt = 0 s = open('archivo.txt', 'rt') lines = s.readlines(20) while len(lines) != 0: for line in lines: lcnt += 1 for ch in line: print(ch, end='') ccnt += 1 lines = s.readlines(10) s.close() print("\n\nCaracteres en el archivo: ", ccnt) print("Lineas en el archivo: ", lcnt) except IOError as e: print("Se produjo un error de E/S: ", strerror(e.errno))



from datetime import datetime def ahora(): return str(datetime.now().day) + "-" + str(datetime.now().month) + "-" + str(datetime.now().year) + "_" + str(datetime.now().hour) + "_" + str(datetime.now().minute) + "_" + str(datetime.now().microsecond) nombreArchivo = ahora() print ("Nombre del archivo es: ", nombreArchivo) archivo = open(nombreArchivo + ".log", "w") # Si el archivo no existe, lo crea. print ("Modo de acceso al archivo es: ", archivo.mode) for texto in range(3): archivo.write(ahora() + " " + str(texto) + "\n") # n es new line archivo.close() # archivo = open(nombreArchivo + ".log", "r") # Abre el archivo en modo lectura print ("Modo de acceso al archivo es: ", archivo.mode) if (archivo.mode == "r"): contenido = archivo.read() print(contenido) print ("El archivo se encuentra en la posición: ", archivo.tell()) archivo.seek(0) print ("El archivo se encuentra en la posición: ", archivo.tell()) if (archivo.mode == "r"): lineas = archivo.readlines() #Lee todo el contenido del archivo por líneas for renglon in lineas: print(renglon) archivo.close()

Falta de portabilidad

Un programa capaz de procesar un archivo de texto y está escrito para Windows, puedes reconocer los extremos de las líneas al encontrar los caracteres \r\n, pero si el mismo programa se ejecuta en un entorno Unix/Linux será completamente inútil, y viceversa: el programa escrito para sistemas Unix/Linux podría ser inútil en Windows.

Estas características indeseables del programa, que impiden o dificultan el uso del programa en diferentes entornos, se denomina falta de portabilidad.

El rasgo del programa que permite la ejecución en diferentes entornos se llama portabilidad.

Un programa dotado de tal rasgo se llama programa portable.

El módulo shutil ofrece una serie de operaciones de alto nivel en archivos y colecciones de archivos.
En particular, se proporcionan funciones que admiten la copia y eliminación de archivos.

El método copy() solo copia el contenido del archivo.
Si desea copiar cosas como la hora de modificación y otros metadatos asociados con el archivo, necesita usar el método copystat()

import os from os import path import shutil from shutil import make_archive from zipfile import ZipFile # def main(): f = "27-10-2020_0_28_156335.log" if path.exists(f): origen = path.realpath(f) print("Ubicación del archivo: ", origen) # destino = origen + ".bak" #Respaldar archivo shutil.copy(origen, destino) #Copia solo contenido shutil.copystat(origen, destino) #Clona el archivo #Renombrar el archivo original nuevoLog = "nuevo.log" otroNombre = path.realpath(nuevoLog) os.rename(f, otroNombre) #Comprimir archivo root_dir, tail = path.split(otroNombre) #No se puede cambiar el nombre de root_dir y tail shutil.make_archive("historico", "zip", root_dir) with ZipFile("otroZip.zip", "w") as nuevoZip: nuevoZip.write(nuevoLog) nuevoZip.write(destino)

Objetos de arreglos de bytes (bytearrays)

Clases especializadas de Python que usa para almacenar datos amorfos.

Datos amorfos son datos que no tienen forma específica, son solo una serie de bytes.

Estos datos amorfos no se pueden almacenarse como cadenas o listas.

Debe haber un contenedor especial capaz de manejar dichos datos.

Este subtipo de PyObject representa un objeto arreglo de bytes de Python, es un arreglo que contiene bytes (amorfos).

data = bytearray(100)

La invocación crea un objeto bytearray capaz de almacenar diez bytes.

Nota: dicho constructor llena todo el arreglo con ceros.

Los bytearrays son mutables, son suceptibles a la función len(), y se puede acceder a cualquiera de sus elementos usando indexación convencional.

No se debe establecer ningún elemento del arreglo de bytes con un valor que no sea un entero, violar esta regla causará una excepción TypeError y tampoco está permitido asignar un valor fuera del rango de 0 a 255 un valor diferente provoca una excepción ValueError.

hex()

Convierte un número entero en una cadena hexadecimal en minúscula con el prefijo "0x".

Si x no es un objeto int de Python, tiene que definir un método __index __() que devuelva un número entero:

print(hex(255)) # 0xff
print(hex(-42)) # -0x2a

En el siguiente ejemplo se usa la función hex() para ver los elementos impresos como valores hexadecimales.

datos = bytearray(10) for idx in range(len(datos)): datos[idx] = 10 - idx for b in datos: print(hex(b))

Cómo escribir y leer bytes de un stream

Herramientas principales para trabajar con streams

El método write() devuelve la cantidad de bytes escritos correctamente.

El método readinto(b) lee bytes en objeto pre-asignado y grabable bytes-like object b, y retorna el número de bytes leído.

Por ejemplo, b puede ser una clase de tipo bytearray. Si el objeto está en modo sin bloquear y no hay bytes disponibles, se retorna None.

from os import strerror # Cómo escribir bytes de un stream data = bytearray(10) for i in range(len(data)): data[i] = 10 + i try: bf = open('file.bin', 'wb') bf.write(data) bf.close() except IOError as e: print("Se produjo un error de E/S: ", strerr(e.errno)) # Cómo leer bytes de un stream data = bytearray(10) try: bf = open('file.bin', 'rb') bf.readinto(data) bf.close() for b in data: print(hex(b), end=' ') except IOError as e: print("Se produjo un error de E/S: ", strerror(e.errno))

read(size=-1)

Lee y retorna hasta size en bytes. Si el argumento está omitido, None, o es negativo, los datos son leídos y retornados hasta que se alcance el fin del archivo. Un objeto bytes vacío se retorna si el stream está al final del archivo.

Si el argumento es positivo, y el stream subyacente no es interactiva, varias lecturas sin formato pueden ser otorgadas para satisfacer la cantidad de byte (al menos que primero se llegue al fin del archivo). Pero para los streams sin formato interactivas, a lo sumo una lectura sin formato será emitida y un resultado corto no implica que se haya llegado al fin del archivo.

Un BlockingIOError se lanza si el stream subyacente está en modo no bloqueo y no tiene datos al momento.

read() invocado sin argumentos, intenta leer todo el contenido del archivo en la memoria, haciéndolo parte de un objeto recién creado de la clase bytes.

Esta clase tiene algunas similitudes con bytearray, con la excepción de una diferencia significativa: es immutable.

from os import strerror data = bytearray(10) for i in range(len(data)): data[i] = 10 + i try: bf = open('file.bin', 'wb') bf.write(data) bf.close() except IOError as e: print("Se produjo un error de E/S: ", strerr(e.errno)) try: bf = open('file.bin', 'rb') data = bytearray(bf.read()) bf.close() for b in data: print(hex(b), end=' ') except IOError as e: print("Se produjo un error de E/S: ", strerror(e.errno))

Si el método read() se invoca con un argumento, se especifica el número máximo de bytes a leer.

El método intenta leer la cantidad deseada de bytes del archivo, y la longitud del objeto devuelto puede usarse para determinar la cantidad de bytes realmente leídos.

from os import strerror data = bytearray(10) for i in range(len(data)): data[i] = 10 + i try: bf = open('file.bin', 'wb') bf.write(data) bf.close() except IOError as e: print("Se produjo un error de E/S: ", strerror(e.errno)) try: bf = open('file.bin', 'rb') data = bytearray(bf.read(5)) bf.close() for b in data: print(hex(b), end=' ') except IOError as e: print("Se produjo un error de E/S:", strerror(e.errno))

urllib es un paquete que recopila varios módulos para trabajar con URL:

• .request abre y lee URLs
• .errorque contiene las excepciones lanzadas por urllib.request
• .parse para parseo URLs
• .robotparser para parseo de archivos robots.txt

Proporciona las clases y el código necesario para realizar solicitudes http, la clase request, devolverá un objeto response.

Códigos de estado de respuesta HTTP

Los códigos de estado de respuesta HTTP indican si se ha completado satisfactoriamente una solicitud HTTP específica. Las respuestas se agrupan en cinco clases:

• Respuestas informativas (100–199)
• Respuestas satisfactorias (200–299) por ejemplo: 200 es OK, 201 - creado, 202 - aceptado
• Redirecciones (300–399)
• Errores de los clientes (400–499) por ejemplo: 400 es Bad Request, 404 - Not Found y
• Errores de los servidores (500–599)

import urllib.request def init(): try: sitio = "http://www.google.com" url = urllib.request.urlopen(sitio) code = url.getcode() if(code == 200): print("getcode... ", code, ": OK") elif(code == 400): print("getcode... ", code, ": Not found") else: print("getcode... ", code) contenido = url.read() print("Contenido de ", sitio, "es: ") print(contenido) except: print("Ha ocurrido un error") if __name__ == "__main__": init()

JSON (JavaScript Object Notation), es un formato de intercambio de datos ligero, inspirado en la sintaxis literal de objetos JavaScript (aunque no es un subconjunto estricto de JavaScript).

json expone una API familiar para los usuarios de los módulos estándar de biblioteca marshal y pickle.

json.loads() Deserializar s (una instancia de str, bytes o bytearray que contiene un documento JSON) a un objeto Python usando esta tabla de conversión.

Si los datos que se deserializan no son un documento JSON válido, se generará un JSONDecodeError.

#https://www.linkedin.com/learning/learning-python-2/working-with-json-data import urllib.request import json jsonFile = "http://earthquake.usgs.gov/earthquakes/feed/v1.0/summary/2.5_day.geojson" url = urllib.request.urlopen(jsonFile) code = url.getcode() if(code == 200): print("getcode... ", code, ": OK") contenido = url.read() print("Contenido de ", jsonFile, "es: ") print(contenido) DeserializaPyObj = json.loads(contenido) if "title" in DeserializaPyObj["metadata"]: print(DeserializaPyObj["metadata"]["title"]) registrados = DeserializaPyObj["metadata"]["count"] print("Eventos registrados: ", registrados) for p in DeserializaPyObj["features"]: print(p["properties"]["place"]) print("------------------------\n") for m in DeserializaPyObj["features"]: if m["properties"]["mag"] >= 5.0: print("%2.1f" % m["properties"]["mag"], m["properties"]["place"]) print("------------------------\n") # Eventos en los que al menos una persona informó haber sentido algo print("\n\nEventos que se sintieron:") for i in DeserializaPyObj["features"]: feltReports = i["properties"]["felt"] if (feltReports != None): if (feltReports > 0): print("%2.1f" % i["properties"]["mag"], i["properties"] ["place"], " reportados " + str(feltReports) + " veces")

Módulo que define una clase HTMLParser que sirve como base para analizar archivos de texto formateados en HTML y XHTML.

getpos()obtiene una tupla que indica número de línea [0] y una posición de carácter [1] en los datos donde, se encontró la coincidencia.

Los manejadores de tags HTML deben tener el nombre correcto handle_comment, con otro nombre no funciona.

Es mejor indicar la codificación que tiene el archivo para evitar errores open("fileName.ext", encoding="utf8")

#https://www.linkedin.com/learning/learning-python-2/parsing-and-processing-html from html.parser import HTMLParser metacount = 0 #Analiza documento HTML class FormatoHTML(HTMLParser): #obtener número de línea [0] y posición [1] de la coincidencia def handle_comment(self, datos): pos = self.getpos() print("\n\t#", datos, "- Comentario encontrado en la línea:", pos[0], "columna:", pos[1], "\n") # function to handle an opening tag in the doc # this will be called when the closing ">" of the tag is reached def handle_starttag(self, tag, attrs): global metacount if tag == "meta": metacount += 1 print("\nmeta tag's encontradas:", metacount, "\n") pos = self.getpos() print("\n\t>>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>>") print("\tTag:", tag, "Inicia en la línea:", pos[0], "columna:", pos[1], "atributos:") if attrs.__len__() > 0: for a in attrs: #Par clave/valor print ("\t\t", a[0],"=",a[1]) # function to handle the ending tag def handle_endtag(self, tag): pos = self.getpos() print("\n\tTag:", tag, "Termina en la línea:", pos[0], "columna:", pos[1], "atributos:") print("\t<<< <<< <<< <<< <<< <<< <<< <<< <<< <<< <<< <<< <<<\n") # function to handle character and text data (tag contents) def handle_data(self, datos): if (datos.isspace()): return print("\n\tContenido encontrado: ", datos) pos = self.getpos() print("\tLínea: ", pos[0], "posición ", pos[1]) def init(): parser = FormatoHTML() #Definir el archivo HTML htmlFile = open("holamundo.html", encoding="utf8") #Validar que si existe el archivo if htmlFile.mode == "r": #Obtener el contenido del documento HTML contenido = htmlFile.read() print("\nBuscando meta tags en el archivo HTML...\n") #Alimentar con el contenido del archivo HTML y ejecutar línea por línea parser.feed(contenido) print ("%d meta tags encontradas" % metacount) else: print("El archivo no existe") if __name__ == "__main__": init()

xml.dom.minidom es una implementación mínima de la interfaz Document Object Model, con una API similar a la de otros lenguajes.

Está destinado a ser más simple que el DOM completo y también significativamente más pequeño.

Los usuarios que aún no dominan el DOM deberían considerar el uso del módulo xml.etree.ElementTree para su procesamiento XML.

import xml.dom.minidom def agregaEtiqueta(etiqueta, valorEtiqueta): tag = doc.createElement(etiqueta) tag.setAttribute(atributo, valorEtiqueta) doc.firstChild.appendChild(tag) def info(etiqueta, atributo): etiquetasEncontradas = doc.getElementsByTagName(etiqueta) print ("\tEtiquetas (", etiqueta, ") encontradas:", etiquetasEncontradas.length) for e in etiquetasEncontradas: print ("\t\t", e.getAttribute(atributo)) #BEGIN doc = xml.dom.minidom.parse("xPersona.xml") print ("Nodo del documento:", doc.nodeName) print ("Primera etiqueta hija:", doc.firstChild.tagName) etiqueta = "habilidad" atributo = "nombre" info(etiqueta, atributo) # Crear un nuevo tag XML y agregarlo a la estructura del documento en memoria valorEtiqueta = "Go" agregaEtiqueta(etiqueta, valorEtiqueta) print("*** Etiqueta agregada ***") info(etiqueta, atributo)

<?xml version="1.0" encoding="UTF-8" ?> <persona> <nombre>Bill</nombre> <apellido>Gates</apellido> <cd>Seattle</cd> <habilidad nombre = "JavaScript"/> <habilidad nombre = "Python"/> <habilidad nombre = "C#"/> <habilidad nombre = "HTML"/> </persona>

pip es un sistema de gestión de paquetes utilizado para instalar y administrar paquetes de software escritos en Python. Muchos paquetes pueden ser encontrados en el Python Package Index (PyPI). Python 2.7.9 y posteriores (en la serie Python2), Python 3.4 y posteriores incluyen pip (pip3 para Python3) por defecto.

pip es un acrónimo recursivo que se puede interpretar como Pip Instalador de Paquetes o Pip Instalador de Python.

El Proyecto Jupyter es una organización sin ánimo de lucro creada para "desarrollar software de código abierto, estándares abiertos y servicios para computación interactiva en docenas de lenguajes de programación".

Creado a partir de IPython en 2014 por Fernando Pérez, el proyecto Jupyter soporta entornos de ejecución en varias docenas de lenguajes de programación.

El nombre del proyecto Jupyter es una referencia a los tres lenguajes de programación principales soportados por Jupyter, que son Julia, Python y R, y también un homenaje a los cuadernos de Galileo que registran el decubrimiento de los satélites de Júpiter.

El proyecto Jupyter ha desarrollado y respaldado los productos de computación interactiva Jupyter Notebook, JupyterHub y JupyterLab, la versión de próxima generación de Jupyter Notebook.

Installing the Jupyter Software

• Install with conda conda install -c conda-forge jupyterlab


• Install with pip pip install jupyterlab

Getting started with the classic Jupyter Notebook

• Install with conda conda install -c conda-forge notebook


• Install with pip pip install notebook

Anaconda es un distribución libre y abierta1​ de los lenguajes Python y R, utilizada en ciencia de datos, y aprendizaje automático (machine learning). Esto incluye procesamiento de grandes volúmenes de información, análisis predictivo y cómputos científicos. Está orientado a simplificar el despliegue y administración de los paquetes de software

Las diferentes versiones de los paquetes se administran mediante el sistema de gestión de paquetes conda, el cual lo hace bastante sencillo de instalar, correr, y actualizar software de ciencia de datos y aprendizaje automático como ser Scikit-team, TensorFlow y SciPy.

La distribución Anaconda es utilizada por 6 millones de usuarios e incluye más de 250 paquetes de ciencia de datos válidos para Windows, Linux y MacOS.

• Abrir consola de Anaconda jupyter lab
  
  
  


• Dar clic en notebook
  
  

Pandas es una herramienta de análisis y manipulación de datos de código abierto rápida, potente, flexible y fácil de usar, construido sobre el lenguaje de programación Python.

En Computación y Ciencia de datos, pandas es una biblioteca de software escrita como extensión de NumPy para manipulación y análisis de datos para el lenguaje de programación Python.
En particular, ofrece estructuras de datos y operaciones para manipular tablas numéricas y series temporales.
Es un software libre distribuido bajo la licencia BSD versión tres cláusulas.
El nombre deriva del término "datos de panel", término de econometría que designa datos que combinan una dimensión temporal con otra dimensión transversal.

• https://pandas.pydata.org/
  • https://pandas.pydata.org/docs/
    • https://pandas.pydata.org/docs/getting_started/index.html#getting-started
      • https://pandas.pydata.org/docs/getting_started/install.html
        • Installing with Anaconda.
        • Installing with Miniconda
        • Installing from PyPI pip install pandas
        • Installing with ActivePython
        • Installing using your Linux distribution’s package manager. p.e sudo apt-get install python3-pandas

Como instalar pandas de: PyPI

Anaconda es una distribución libre y abierta​ de los lenguajes Python y R, utilizada en ciencia de datos, y aprendizaje automático (machine learning).

Anaconda fue construida por científicos de datos, para científicos de datos.

Las soluciones Anaconda son una tecnología seria para aplicaciones de ML y ciencia de datos reales. Anaconda es versátil: estará listo para resolver problemas que ni siquiera sabe que tiene todavía.

Al descargar e instalar Anaconda una de sus herramientas es Jupyter

Acceda al sitio de Anaconda y descargue la versión que le convenga: Installing on Windows

Proyecto Jupyter

El Proyecto Jupyter es una organización sin ánimo de lucro creada para "desarrollar software de código abierto, estándares abiertos y servicios para computación interactiva en docenas de lenguajes de programación".

Creado a partir de IPython en 2014 por Fernando Pérez, el proyecto Jupyter soporta entornos de ejecución en varias docenas de lenguajes de programación.

El nombre del proyecto Jupyter es una referencia a los tres lenguajes de programación principales soportados por Jupyter, que son Julia, Python y R, y también un homenaje a los cuadernos de Galileo que registran el descubrimiento de los satélites de Júpiter.

El proyecto Jupyter ha desarrollado y respaldado los productos de computación interactiva Jupyter Notebook, JupyterHub y JupyterLab, la versión de próxima generación de Jupyter Notebook.

Una vez instalado Anaconda puede abrir o ejecutar Jupyter.

Jupyter Notebook

Jupyter Notebook (anteriormente IPython Notebooks) es un entorno informático interactivo basado en la web para crear documentos de Jupyter notebook.

El término "notebook" puede hacer referencia coloquialmente a muchas entidades diferentes, principalmente la aplicación web Jupyter, el servidor web Jupyter Python o el formato de documento Jupyter según el contexto.

Un documento de Jupyter Notebook es un documento JSON, que sigue un esquema versionado y que contiene una lista ordenada de celdas de entrada/salida que pueden contener código, texto (usando Markdown), matemáticas, gráficos y texto enriquecidos, generalmente terminado con la extensión ".ipynb".

Home page, crear o seleccionar una notebook

De inicio si nunca has utilizado Jupyter tendras una pequeña curva de aprendizaje para familiarizarte con su forma de trabajo, por ejemplo:

Lo primero que debes saber es que Jupyter abre un entorno web, es decir, vas a trabajar en una página web que se abre al iniciar Jupyter.

Por cierto puedes abrir Anacanda Navigator que es una aplicación de escritorio y que muestra todas sus herramientas, entre ella Jupyter y desde ahí solo basta un clic para abrir.

O bien puedes ejecutar directamente Jupyter sin abrir Anaconda Navigator, en este caso se abre un servidor web por lo que se tiene una consola, la cual indica instrucciones para su uso.

En un browser o navegador se abre la siguiente URL http://localhost:8888/tree

Donde localhost hace referencia a un servidor web o http local y los dos puntos sirven para especificar el puerto 8888 donde estará funcionando, es decir, donde el servidor HTTP “escucha” la petición hecha por un cliente.

Se presentan tres pestañas: Files, donde puede navegar entre los directorios de la máquina, Running, Actualmente ejecutando procesos de Jupyter y clusters, ipyparallel.

Los botones:

• Upload, para el envío de archivos al servidor
• New, la parte interesante, puedes crean una notebook, la cual trabajará con el compilador de tu elección.
  
  Nota. Los tipos de Notebooks dependeran de lo que se tenga instalado, es decir, si en la máquina esta instalado Python, se listará como notebook, lo mismo para Julia y lo mismo para los kernels que Jupyter detecte se encuentran instalados y su versión correspondiente.
  
  También es posible crear por ejemplo: un archivo de texto, un directorio o folder y otro punto interesente es que es posible abrir una terminal.

Nueva notebook

Al dar clic en el kernel de Python por ejemplo, se abre una nueva página, la cual no tiene título, pero que es posible almacenar con un nombre. Además indica cuando se hizo el último checkpoint



Un menú principal con las opciones: File, Edit, View, insert, Cell, Kernel, Widgets, Help, al extremo derecho de este menú se muestra el lenguaje seleccionado que puede ser Python 3 por ejemplo.

Debajo del menú principal tenemos unos accesos directos representados por un ícono, así como una lista seleccionable que contiene por ejemplo: Code, Markdown, Raw NBconvert, Heading, con estas opciones cambiamos el tipo de edición, por ejemplo si estamos documentando tal vez lo estemos haciendo con Markdown, pero si estamos codificando será Code.

Celdas

Debajo del menú se inicia la notebook, por defecto muestra una celda.



Aquí es donde escribes las instrucciones por ejemplo en Python, despúes de donde se indica In [ ]: y en la parte sombreada, podrías escribir

print("Hola mundo")

y para ejecutar la instrucción debes dar CTRL + Intro o con el ícono que dice Run

Ejecutada la celda inicia una numeración In [n]:

Si la instrucción esta procesandose se mostrara un *

Al final de su ejecución debajo de la celda se muestra el resultado o un mensaje de error si lo hubo.

Insertar una celda

De lo más simple, de los accesos director, dar clic en el ícono de +.

Cambiar orden de celdas

Simple, coloca el cursor en la celda que deseas mover y con los íconode de las flechas arriba y abajo, situar en el lugar que mejor convenga.

Al ejecutar las celdas, el número de celda cambia y se reordena.

Cortar, copiar y pegar celdas

Es posible Cortar, copiar y pegar celdas, como en cualquier editor de texto, las cortamos o copiamos y pegamos en donde sea conveniente.

Kernel: Interrupt, restart, reconnect, shutdown

Permite controlar la ejecución de celdas o la notebook, es decir el kernel.

Si es necesario instalar paquetes, podemos usar la herramienta de Anaconda llamada Anaconda prompt, al ejecutar la herramienta se abre una terminal.

Escribimos el comando: conda install nombre_paquete

Apache Spark es un framework de computación en clúster open-source.

Fue desarrollada originariamente en la Universidad de California, en el AMPLab de Berkeley.

El código base del proyecto Spark fue donado más tarde a la Apache Software Foundation que se encarga de su mantenimiento desde entonces.

Spark proporciona una interfaz para la programación de clusters completos con Paralelismo de Datos implícito y tolerancia a fallos.

Apache Spark se puede considerar un sistema de computación en clúster de propósito general y orientado a la velocidad.

Proporciona APIs en Java, Scala, Python, R y un motor optimizado que soporta la ejecución de grafos en general.

También soporta un conjunto extenso y rico de herramientas de alto nivel entre las que se incluyen Spark SQL (para el procesamiento de datos estructurados basada en SQL), MLlib para implementar machine learning, GraphX para el procesamiento de grafos y Spark Streaming.

Para instalar lo usual, acceder al sitio del producto spark.apache.org buscar la sección de descarga, para cuando se consulto la página indicaba seleccionar la versión de spark y el tipo de paquete.

Para la instalación y configuración sigan las instrucciones del sitio oficial.

Una vez instalado para trabajar con el ambiente de Spark deben acceder al directorio donde este fue instalado y configurado, el comando es el siguiente:

C:\Spark\spark-2.4.5-bin-hadoop2.7\bin\spark-shell

	Welcome to
	____              __
   / __/__  ___ _____/ /__
  _\ \/ _ \/ _ `/ __/  '_/
 /___/ .__/\_,_/_/ /_/\_\   version 2.4.7
	/_/

Using Scala version 2.11.12 (Java HotSpot(TM) 64-Bit Server VM, Java 11.0.9)
Type in expressions to have them evaluated.
Type :help for more information.

scala>

10 minutes to pandas

Su principal desarrollador, Wes McKinney, empezó a desarrollar Pandas en el año 2008 mientras trabajaba en AQR Capital por la necesidad que tenía de una herramienta flexible de alto rendimiento para realizar análisis cuantitativo en datos financieros.

Antes de dejar AQR convenció a la administración de la empresa de distribuir esta biblioteca bajo licencia de código abierto.

Otro empleado de AQR, Chang Ella, se unió en 2012 al esfuerzo de desarrollo de la biblioteca.

Pandas es una herramienta de análisis y manipulación de datos de código abierto rápida, potente, flexible y fácil de usar, construido sobre el lenguaje de programación Python.

En Computación y Ciencia de datos, Pandas es una biblioteca de software escrita como extensión de NumPy para manipulación y análisis de datos para el lenguaje de programación Python.

En particular, ofrece estructuras de datos y operaciones para manipular tablas numéricas y series temporales.

Es un software libre distribuido bajo la licencia BSD versión tres cláusulas.​

El nombre deriva del término "datos de panel", término de econometría que designa datos que combinan una dimensión temporal con otra dimensión transversal.

Para usar Pandas se hace a través de un import y se recomienda se declare como pd como convención.



pandas.read_csv

De la misma manera por convención un DataFrame se declara como df, por ejemplo pandas.read_csv que lee un archivo de valores separados por comas (csv) en un Dataframe

DataFrame es una estructura de datos etiquetada bidimensional con columnas de tipos potencialmente diferentes.

Puede pensar en ello como una hoja de cálculo o una tabla SQL, o un dict de objetos Series. Generalmente es el objeto de pandas más utilizado.

Junto con los datos, puede pasar opcionalmente argumentos de índice (etiquetas de fila) y columnas (etiquetas de columna).

Si pasa un índice y / o columnas, está garantizando el índice y / o columnas del DataFrame resultante.

Por lo tanto, un dict de Serie más un índice específico descartará todos los datos que no coincidan con el índice pasado.

Si no se pasan las etiquetas de los ejes, se construirán a partir de los datos de entrada basándose en reglas de sentido común.

Ejemplo de un un archivo csv: Import_User_Sample_en.csv

En Windows debemos tener en cuenta la sintaxis, los signos / (diagonal o barra) y \ slash (diagonal inversa o barra inversa) tienen significados y usos diferentes en Jupyter.

Las siguientes rutas o paths pueden resultar correctos:

"C:\\Users\\usuarioWindows>\\Documents\\pandas\\ejemplo.csv"

"C:/Users/usuarioWindows/Documents/pandas/ejemplo.csv"

pandas.DataFrame.head

DataFrame.head(n=5)[source]

Devuelve las primeras n filas. Si no se especifica el número de filas por defecto son las primeras 5.

Esta función devuelve las primeras n filas del objeto según la posición.

Su contraparte es .tail(), devuelve las últims n filas del objeto.

Leer y ver el contenido de un archivo csv

#usar la biblioteca pandas import pandas as pd #leer el archivo csv como dataframe df = pd.read_csv("C:/Users/usuarioWindows/Documents/pandas/ejemplo.csv") #ver el contenido df.head()

Note que el índice inicia en 0 y que también puede limitar el número de renglones o filas a leer desde la lectura del archivo al incluir nrows:

df = pd.read_csv("C:/Users/usuarioWindows/Documents/pandas/ejemplo.csv", nrows = 3)

DataFrame.sample(n=None, frac=None, replace=False, weights=None, random_state=None, axis=None)

pandas.DataFrame.sample

Devuelve una muestra aleatoria de elementos de un eje de objeto.

df.sample(frac = 1)

Donde frac decimal, opcional. Fracción de elementos del eje para devolver. 1 genera un índice aleatorio en todas las filas.

pandas.DataFrame.columns: Index

pandas.DataFrame.columns

Muestra las etiquetas de columna del DataFrame.

df.columns

Out[n]: Index(['User Name', 'First Name', 'Last Name', 'Display Name', 'Job Title', 'Department', 'Office Number', 'Office Phone', 'Mobile Phone', 'Fax', 'Address', 'City', 'State or Province', 'ZIP or Postal Code', 'Country or Region'], dtype='object')

pandas.DataFrame.index

DataFrame.index: Index

El index (etiquetas de fila) del DataFrame. Recupere las etiquetas de índice.

df.index

Out[n]: RangeIndex(start=0, stop=5, step=1)

Si deseamos ver los valores de una columna basta con indicar a través de la notación de punto el nombre de la columna, ya que es un atributo del dataframe.

df.Department

Si la columna tiene espacios:

df["Job Title"]

Nota: Working With Pandas: Fixing Messy Column Names:

df.columns = df.columns.str.strip().str.lower().str.replace(' ', '_').str.replace('(', '').str.replace(')', '')

Si se necesita conocer el tipo de datos de cada columna:

df.dtypes

pandas.DataFrame.values

property DataFrame.values

Devuelve una representación Numpy del DataFrame.

Se recomienda usar DataFrame.to_numpy() en su lugar.

df.values

Out[n]: array([['chris@contoso.com', 'Chris', 'Green', 'Chris Green', 'IT Manager', 'Information Technology', 123451, '123-555-1211', '123-555-6641', '123-555-9821', '1 Microsoft way', 'Redmond', 'Wa', 98052, 'United States'], ['ben@contoso.com', 'Ben', 'Andrews', 'Ben Andrews', 'IT Manager', 'Information Technology', 123452, '123-555-1212', '123-555-6642', '123-555-9822', '1 Microsoft way', 'Redmond', 'Wa', 98052, 'United States'], ['david@contoso.com', 'David', 'Longmuir', 'David Longmuir', 'IT Manager', 'Information Technology', 123453, '123-555-1213', '123-555-6643', '123-555-9823', '1 Microsoft way', 'Redmond', 'Wa', 98052, 'United States'], ['cynthia@contoso.com', 'Cynthia', 'Carey', 'Cynthia Carey', 'IT Manager', 'Information Technology', 123454, '123-555-1214', '123-555-6644', '123-555-9824', '1 Microsoft way', 'Redmond', 'Wa', 98052, 'United States'], ['melissa@contoso.com', 'Melissa', 'MacBeth', 'Melissa MacBeth', 'IT Manager', 'Information Technology', 123455, '123-555-1215', '123-555-6645', '123-555-9825', '1 Microsoft way', 'Redmond', 'Wa', 98052, 'United States']], dtype=object)

Obtener filas por rango

df[min:max]

Obtiene un rango de filas desde el limite inferior y hasta el limite superior.

Recuerde que el índice inicia en 0

Obtener filas por condiciones

df[ df["Job Title"] == "PM"] #(Obtiene los primeros 5) df[ df["Department"] == "Information Technology"].head() df[ df["Office Number"] > 123455] df[ df["Job Title"] != "IT Manager"] df[ ( df["City"] == "CDMX" ) & ( df["Office Number"] >= 123459 ) ] df[ ( df.index <= 1 ) | ( df["Office Number"] >= 123459 ) ]

Obtener filas por funciones con condiciones

df[ df["Job Title"].isin( [ "IT Manager","PM","Scrum Master" ] ) ]

pandas.isna

Detecta valores faltantes para un objeto tipo matriz.

Esta función toma un objeto escalar o similar a una matriz e indica si faltan valores (NaN (Not a Number) en matrices numéricas, Ninguno o NaN en matrices de objetos, NaT (Not a Time) en datetimelike).

df[ pd.isna( df["User Name"] ) | pd.isna( df["First Name"] ) ] len( df[ pd.isna( df["User Name"] ) | pd.isna( df["First Name"] ) ] )

DataFrame

Datos tabulares bidimensionales, de tamaño mutable y potencialmente heterogéneos.

La estructura de datos también contiene ejes etiquetados (filas y columnas).

Las operaciones aritméticas se alinean en las etiquetas de fila y columna.

Se puede considerar como un contenedor similar a un dict para los objetos de la serie. La estructura de datos primaria de los pandas.

Creando un DataFrame pasando un dict de objetos que se pueden convertir a series.

import numpy as np import pandas as pd #Crear DataFrame df_my = pd.DataFrame( { "A": 1.0, "B": pd.Timestamp("20130102"), "C": pd.Series(1, index=list(range(4)), dtype="float32"), "D": np.array([3] * 4, dtype="int32"), "E": pd.Categorical(["test", "train", "test", "train"]), "F": "foo", } )

Escribe el objeto en una hoja de Excel.

df_my.to_excel("fromPandas.xlsx", sheet_name='valores')

pandas.read_excel

Escribe el objeto en una hoja de Excel.

import numpy as np import pandas as pd pd.read_excel('fromPandas.xlsx')

pandas.DataFrame.to_csv

Escriba el objeto en un archivo de valores separados por comas (csv).

#Crear dataframe df_csv = pd.DataFrame( {'name': ['Raphael', 'Donatello'], 'mask': ['red', 'purple'], 'weapon': ['sai', 'bo staff']}) #Almacenar como csv uft-8 df_csv.to_csv('fileCSV.csv', encoding='utf-8')

pandas.read_csv

Lea un archivo de valores separados por comas (csv) en DataFrame.

También admite, opcionalmente, iterar o dividir el archivo en trozos.

#Leer y mostrar csv pd.read_csv('fileCSV.csv')

Crear un archivo zip que contenga un archivo csv

#Configurar opciones de compresión para el archivo compression_opts = dict(method='zip', archive_name='out.csv') #Almacenar el archivo como csv contenido en un zip df_csv.to_csv('out.zip', index=False, compression=compression_opts)

Es posible cambiar los valores de una columna y adecuarlos a conveniencia.

df["Office Number"] = df["Office Number"] + 1

Así como aplicar funciones como round() y otras funciones.

Se puede aplicar a la propia columna o al dar un nombre se crea una nueva columna:

df["Nueva columna"] = df["Office Number"] + 1

La nueva columna es creada al final de todas.

Para eliminar esta columna use del(dataframe["nombre columna"])

del(df["Nueva columna"])

Para eliminar más de una columna use drop(dataframe["col a","col b","col b",..."col n"]) Elimina las etiquetas especificadas de filas o columnas.

pandas.DataFrame.drop

Elimina filas o columnas especificando los nombres de las etiquetas y el eje correspondiente, o especificando directamente los nombres de índice o columna.

Cuando se utiliza un índice múltiple, las etiquetas de diferentes niveles se pueden eliminar especificando el nivel.

df.drop(["User Name", "First Name", "Last Name"], axis=1)

NOTA 1: Si no especifica axis se genera un error, es necesario indicar de que eje se quiere eliminar.

NOTA 2: Para afectar el dataframe con esta función, sera necesario entonces asignar el resultado a la variable dataframe

df = df.drop(["User Name", "First Name", "Last Name"], axis=1)

Otra manera es usar el parámetro inplace = True

df.drop(["Fax"], axis=1, inplace = True)

Para eliminar una columna puede usar df.drop(índice)

df = df.drop(2)

Para eliminar más de una columna puede usar df.drop( range(start, stop[, step]) )

El siguiente ejemplo elimina los pares incluso el 10.

df = df.drop( range(0, 10 + 1, 2) )

NOTA: Recuerde el uso de asignar a la variable dataframe el resultado.

pandas.DataFrame.append

Agrega filas de otros al final del dataframe que invoca, devolviendo un nuevo objeto.

Las columnas en otros que no están en quien invoca se agregan como nuevas columnas.

Podemos crear nuevos dataframes a partir de uno existente:

df_tester = df[ df["Job Title"] == "Tester" ] df_pm = df[ df["Job Title"] == "PM" ]

Así como es posible agregar un dataframe a otro:

df_team = df_tester.append(df_pm)

pandas.read_excel

Lee un archivo de Excel en un DataFrame de pandas. Admite extensiones de archivo xls, xlsx, xlsm, xlsb, odf, ods y odt leídas desde un sistema de archivos local o URL.

(archivo MS-Excel ejemplo: Financial Sample.xlsx)

df = pd.read_excel("C:/Users/<userName>/Documents/pandas/<fileName>.xlsx")

Admite una opción para leer una sola hoja o una lista de hojas.

pandas.DataFrame.groupby

Una operación de grupo implica una combinación de:

1. Dividir el objeto,
2. Aplicar una función y
3. Combinar los resultados.

Esto se puede utilizar para agrupar grandes cantidades de datos y calcular operaciones en estos grupos.

(archivo MS-Excel ejemplo: Financial Sample.xlsx)

Muestra todas las columnas del dataframe con las filas agrupadas por la columna Country:

df.groupby(by="Country").sum()

df.groupby(by="Country")["Units Sold"].sum()

Es necesario señalar que el orden en el cual se lista más de una columna en groupby cambia el sentido de la lectura y la información que deseamos obtener:

df.groupby(by= ["Segment", "Country"])["Units Sold"].describe()

pandas.core.groupby.DataFrameGroupBy.describe

Genera estadísticas descriptivas.

Las estadísticas descriptivas incluyen aquellas que resumen la tendencia central, la dispersión y la forma de la distribución de un conjunto de datos , excluyendo los valores de NaN.

Analiza series numéricas y de objetos, así como conjuntos de columnas DataFrame de tipos de datos mixtos. La salida variará según lo que se proporcione. Consulte las notas a continuación para obtener más detalles.

df.groupby(by= ["Country", "Segment"])["Units Sold"].describe()

La salida agrupa por Country, que forma parte de las columnas y las columnas de describe() son count, mean, std, min, 25%, 50%, 75% (cuartiles), max.

drop_duplicates

Devuelve DataFrame con filas duplicadas eliminadas.

Tener en cuenta ciertas columnas es opcional. Los índices, incluidos los índices de tiempo, se ignoran.

El siguiente ejercicio del dataframe ramen contiene valores repetidos, que se pueden tratar:

ramen = pd.DataFrame({ 'brand': ['Yum Yum', 'Yum Yum', 'Indomie', 'Indomie', 'Indomie'], 'style': ['cup', 'cup', 'cup', 'pack', 'pack'], 'rating': [4, 4, 3.5, 15, 5] })

De forma predeterminada, elimina las filas duplicadas en función de todas las columnas:

ramen.drop_duplicates()

Para eliminar duplicados en columnas específicas, use subset.

ramen.drop_duplicates(subset=['brand'])

Para eliminar duplicados y conserva última coincidencia, use keep.

ramen.drop_duplicates(subset=['brand', 'style'], keep='last')

Colorea el fondo con un estilo degradado.

El color de fondo se determina según los datos de cada columna (opcionalmente fila). Requiere matplotlib.

dataframe.style.background_gradient()

NumPy v1.20 Manual

El paquete fundamental para la informática científica con Python (numpy.org/install)

Distribución de Anaconda: incluye Python, NumPy y muchos otros paquetes de uso común para la informática científica y la ciencia de datos.

NumPy es el paquete fundamental para la computación científica en Python. Es una biblioteca de Python que proporciona un objeto de matriz multidimensional, varios objetos derivados (como matrices y matrices enmascaradas) y una variedad de rutinas para operaciones rápidas en matrices, que incluyen manipulación matemática, lógica, de formas, clasificación, selección, E/S, transformadas discretas de Fourier, álgebra lineal básica, operaciones estadísticas básicas, simulación aleatoria y mucho más.

En el núcleo del paquete NumPy , está el objeto ndarray. Esto encapsula matrices n-dimensionales de tipos de datos homogéneos, con muchas operaciones que se realizan en código compilado para el rendimiento.

Existen varias diferencias importantes entre las matrices NumPy y las secuencias estándar de Python

NumPy es una biblioteca para el lenguaje de programación Python que da soporte para crear vectores y matrices grandes multidimensionales, junto con una gran colección de funciones matemáticas de alto nivel para operar con ellas.

El precursor de NumPy, Numeric, fue creado originalmente por Jim Hugunin con contribuciones de varios otros desarrolladores.

En 2005, Travis Oliphant creó NumPy incorporando características de la competencia Numarray en Numeric, con amplias modificaciones.

NumPy es un software de código abierto y cuenta con muchos colaboradores.

import numpy as np

series

ndarray unidimensional con etiquetas de eje (incluidas series de tiempo).

Las etiquetas no necesitan ser únicas, pero deben ser de tipo hashtable.

El objeto admite la indexación basada tanto en números enteros como en etiquetas y proporciona una serie de métodos para realizar operaciones relacionadas con el índice.

Los métodos estadísticos de ndarray se han anulado para excluir automáticamente los datos faltantes (actualmente representados como NaN).

pd.Series([1, 2, 3]).values

get_dummies

Convierte la variable categórica en variables ficticias/indicadoras.

pd.get_dummies(pd.Series(list('abca')))

numpy.array

Crea una matriz y devuelve ndarray un objeto de matriz que cumple los requisitos especificados.

array([1, 2, 3])

Out[n]: array([1, 2, 3])

np.array([1, 2, 3.0])

Upcasting

Out[n]: array([1. 2., 3.])

Más de una dimensión:

np.array([[1, 2], [3, 4]])

Out[n]:

array([[1, 2],
	   [3, 4]])

Acceso a los elementos de un array

Creación de la matriz:

matriz = np.array( [ ['a', 'b', 'c'], ['x', 'y', 'z'], ['d', 'e', 'f'], ['m', 'n', 'o'] ] )

Mostrar la matriz:

matriz

Out[n]:

array([['a', 'b', 'c'],
       ['x', 'y', 'z'],
       ['d', 'e', 'f'],
       ['m', 'n', 'o']], dtype='<U1')				
			

El acceso al array se hace mediante corchetes haciendo referencia al índice del elemento.

Nota: recuerde que los elementos de una matriz inician con el índice 0

matriz[1][1]

Out[n]: 'y'

matriz[1,1]

Out[n]: 'y'

matriz[2]

Out[n]: array(['d', 'e', 'f'], dtype='<U1')

De la siguiente matriz...

cuatro = np.array(
   [
      [#0i
         [0,0,0,0], ##0j
         [0,0,4,0]  ##1j
      ],
      [#1i
         [0,0,0,0], ##0j
         [0,0,0,0]  ##1j
      ],
      [#2i
         [0,0,0,0], ##0j
         [0,0,0,0]  ##1j
      ]
    ###k  0 1 2 3 
   ]
)
cuatro

¿Cuál sería la salida?

cuatro[0,1,2]

De la siguiente matriz...

cinco = np.array(
   [
      [#0i
         [0,0,0,0], ##0j
         [0,0,4,0]  ##1j
      ],
      [#1i
         [0,0,0,0], ##0j
         [0,0,0,0]  ##1j
      ],
      [#2i
         [0,0,0,0], ##0j
         [5,0,0,0]  ##1j
      ]
    ###k  0 1 2 3 
   ]
)
cinco

¿Cuál sería la salida?

cinco[2,1,0]

ndarray

Un objeto de matriz representa una matriz homogénea y multidimensional de elementos de tamaño fijo.

Un objeto de tipo de datos asociado describe el formato de cada elemento en el array (su orden de bytes, cuántos bytes ocupa en la memoria, si es un entero, un número de coma flotante u otra cosa, etc.)

np.ndarray(shape=(2,2), dtype=float, order='F')

numpy.ma.zeros

Devuelve una nueva matriz de forma y tipo dados, llena de ceros.

np.zeros(0)

Out[n]: array([], dtype=float64)

np.zeros(1)

Out[n]: array([0.])

np.zeros(2,)

Out[n]: array([0., 0.])

np.zeros((2,3), dtype=int)

Out[n]: array([[0, 0, 0],[0, 0, 0]])

np.zeros((3,2), dtype=int)

Out[n]: array([[0, 0],[0, 0],[0, 0]])

numpy.ma.ones

Devuelve una nueva matriz de forma y tipo dados, llena de unos.

np.ones((3,2), dtype=int)

Out[n]: array([[1, 1],[1, 1],[1, 1]])

Es posible hacer operaciones entre arrays siempre y cuando tengan las mismas dimensiones.

a = np.ones((3,2), dtype=int) b = np.ones((3,2), dtype=int) a + b

Out[n]: array([[2, 2], [2, 2], [2, 2]])

numpy.ma.reshape

Devuelve una matriz que contiene los mismos datos con una nueva forma.

np.reshape( [1,2,3,1,2,3,1,2,3],(3,3,1) )

Out[n]: array([[[1], [2], [3]], [[1], [2], [3]], [[1], [2], [3]]])

np.reshape( [1,2,3,1,2,3,1,2,3],(1,3,3) )

Out[n]: array([[[1, 2, 3], [1, 2, 3], [1, 2, 3]]])

numpy.random.rand

Valores aleatorios en una forma determinada.

np.random.rand(2,4)

Out[n]: array([[0.24841231, 0.27484909, 0.16803216, 0.7224534 ], [0.36331669, 0.24167854, 0.2862648 , 0.52071995]])

En probabilidad y estadística, la correlación indica la fuerza y la dirección de una relación lineal y proporcionalidad entre dos variables estadísticas cuantitativas.

Se considera que dos variables cuantitativas están correlacionadas cuando los valores de una de ellas varían sistemáticamente con respecto a los valores homónimos de la otra:

   si tenemos dos variables (A y B)

existe correlación entre ellas

   si al disminuir los valores de A lo hacen también los de B y viceversa.

La correlación entre dos variables no implica, por sí misma, ninguna relación de causalidad.

¿Y cómo se hace esto en Python?

Recordemos que para eso se crean las bibliotecas, funciones, paquetes, etc.

numpy.corrcoef

Devuelve los coeficientes de correlación producto-momento de Pearson.

Consulte la documentación de cov para obtener más detalles.

La relación entre la matriz de coeficientes de correlación, R, y la matriz de covarianzas, C, es



Los valores de R se encuentran entre -1 y 1, inclusive.

Para usar numpy.corrcoef() es necesario que el dataframe no contenga valores NaN o la función no permite valores faltantes.

Por lo que será necesario omitirlos o limpiarlos, para ello puede usar de Pandas: pandas.DataFrame.dropna que elimina valores faltantes.

dataframe.dropna( inplace = True, subset = ["col_a", "col_b"] )

Cuando el dataframe no tiene valores faltantes entonces ya se puede usar numpy.corrcoef():

numpy.corrcoef( dataframe[ "col_a" ], dataframe[ "col_b" ],<i>... dataframe[ "col_n" ]</i> )

pandas.DataFrame.dropna

dropna

Elimina los valores faltantes.

df = pd.DataFrame( { "name": ['Alfred', 'Batman', 'Catwoman'], "toy": [np.nan, 'Batmobile', 'Bullwhip'], "born": [pd.NaT, pd.Timestamp("1940-04-25"), pd.NaT] } ) df.dropna()

pandas.DataFrame.corr

pandas.DataFrame.corr

Calcula la correlación de columnas por pares, excluyendo NA/valores nulos.

Como buena practica elimine primero del dataframe aquellas columnas que no son numéricas, esto se puede hacer usando dataframe.drop()

(archivo MS-Excel ejemplo: Financial Sample.xlsx)

df.drop( inplace= True, columns = ["Segment", "Country", "Product", "Discount Band", "Month Name"])

Limpio el dataframe puede ejecutar:

dataframe.corr()

percentile

Calcule el percentil q-ésimo de los datos a lo largo del eje especificado.

Devuelve el q-ésimo percentil (s) de los elementos de la matriz.

Nota: La mediana es el segundo cuartil

¿Qué es el rango intercuartílico?

El rango intercuartílico es la diferencia entre el tercer cuartil y el primer cuartil.

Es una medida de la dispersión estadística.

Q1 = np.percentile(df["Gross Sales"],25) Q3 = np.percentile(df["Gross Sales"],75) rangoIntercuartilico = Q3 - Q1 rangoIntercuartilico

from_records

Convierte un ndarray estructurado o de registro en DataFrame.

Crea un objeto DataFrame a partir de un ndarray estructurado, una secuencia de tuplas o dictados, o un DataFrame.

Ejercicio

Podemos definir en un array los valores de un DataFrame:

valores = [ ( "Marie Curie", "Científica", "07-11-1867",0 ), ( "Ada Lovelace", "Matemático", "10-12-1815",3 ), ( "Anna Isabella Noel Byron", "Matemático", "17-05-1792",1 ), ( "Augusta Leigh", "Poeta", "06-01-1783",7 ), ( "Claire Clairmont", "Escritora", "27-04-1798",1 ), ( "Remedios Varo", "Pintora", "16-12-1908",0 ), ( "Leonora Carrington", "Pintora", "06-04-1917",0 ), ( "Dorothea Tanning", "Pintora", "25-08-1910",0 ), ( "Leonor Fini", "Artista", "30-08-1907",0 ), ( "Kay Sage", "Artista", "25-06-1898",0 ), ( "Rosalind Franklin", "Química", "25-07-1920",2 ), ( "Simone de Beauvoir", "Filósofa", "09-01-1908", ), ( "Valentina Tereshkova", "Cosmonauta", "06-03-1937",1 ), ( "Amelia Earhart", "Aviadora", "24-07-1897", ), ( "Gertrude Belle Elion", "Bioquímico", "23-01-1918", ), ( "Malala Yousafzai", "Activista", "12-07-1997", ), ( "Clara Campoamor", "profe", "12-02-1888",2 ), ( "Albert Einstein", "Físico", "14-03-1879",3 ), ( "Isaac Newton", "Físico", "04-01-1643",0 ), ( "Stephen Hawking", "Físico", "08-01-1942",3 ), ( "Galileo Galilei", "Astrónomo", "15-02-1564",0 ), ( "Nicolás Copérnico", "Astrónomo", "19-02-1473",0 ), ( "Johannes Kepler", "Astrónomo", "27-12-1571",3 ), ( "Leonardo da Vinci", "Polimatía", "15-04-1452",0 ), ( "Miguel Ángel", "Arquitecto", "06-03-1475",0 ), ( "Salvador Dalí", "Pintor", "11-05-1904",0 ), ( "Vincent van Gogh", "Pintor", "30-03-1853",0 ), ( "Aristóteles", "Filósofo", "384 a. C.",0 ), ( "Platón", "Filósofo", "",0 ), ( "Pitágoras", "Filósofo", "",6 ), ( "Sócrates", "Filósofo", "399 a. C.",0 ), ( "Immanuel Kant", "Filósofo", "22-04-1724",0 ), ( "René Descartes", "Filósofo", "31-03-1596",0 ) ]

Y en otro array los datos para ese DataFrame:

datos = [ "Persona", "Profesion", "Fecha", "Hijos" ]

Solo resta convertir a DataFrame:

df = pd.DataFrame.from_records( valores, columns = datos )

Si deseamos obtener valores únicos de una columna podemos usar drop_duplicates: (manteniendo solo la primer coincidencia)

pro = df.drop_duplicates( subset = "Profesion", keep = "first" )

Si necesitamos utilizar solo ciertos datos o columnas, entonces:

data = pro[ [ "Persona", "Profesion" ] ]

join

Une columnas de otro DataFrame.

Unir columnas con otro DataFrame en el índice o en una columna clave.

Une eficientemente varios objetos DataFrame por índice a la vez pasando una lista.

Si tenemos un primer DataFrame:

df = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3', 'K4', 'K5'], 'A': ['A0', 'A1', 'A2', 'A3', 'A4', 'A5']})

Y tenemos otro DataFrame:

other = pd.DataFrame({'key': ['K0', 'K1', 'K2'], 'B': ['B0', 'B1', 'B2']})

Es posible unirlos a un DataFrame utilizando sus índices:

df.join(other, lsuffix='_caller', rsuffix='_other')

Si queremos unir usando las columnas de clave, debemos configurar la clave para que sea el índice tanto en df como en otros.

El DataFrame unido tendrá key como índice.

df.set_index('key').join(other.set_index('key'))

Otra opción para unir usando las columnas clave es usar el parámetro on.

DataFrame.join siempre usa el índice de other, pero podemos usar cualquier columna en df.

Este método conserva el índice del DataFrame original en el resultado.

df.join(other.set_index('key'), on='key')

merge

merge u objetos de serie con nombre, con un join de estilo de base de datos.

La unión se realiza en columnas o índices.

Si une columnas en columnas, se ignorarán los índices de DataFrame.

De lo contrario:

Si se unen índices en índices o índices en una columna o columnas, el índice se transferirá.

Al realizar una fusión cruzada, no se permiten especificaciones de columna para fusionar.

df1 = pd.DataFrame( {'lkey': ['foo', 'bar', 'baz', 'foo'],'value': [1, 2, 3, 5]} ) df2 = pd.DataFrame( {'rkey': ['foo', 'bar', 'baz', 'foo'],'value': [5, 6, 7, 8]} )

Hacer merge de df1 y df2 en las columnas clave y clave.

Las columnas de valor tienen los sufijos predeterminados, _x y _y, agregados.

df1.merge(df2, left_on='lkey', right_on='rkey')

Combine DataFrames df1 y df2 con los sufijos left y right especificados adjuntos a las columnas superpuestas.

df1.merge( df2, left_on='lkey', right_on='rkey',suffixes=('_left', '_right') )

Matplotlib es una biblioteca completa para crear visualizaciones estáticas, animadas e interactivas en Python.

Matplotlib es una biblioteca para la generación de gráficos a partir de datos contenidos en listas o arrays en el lenguaje de programación Python y su extensión matemática NumPy.

Proporciona una API, pylab, diseñada para recordar a la de MATLAB que es un sistema de cómputo numérico que ofrece un entorno de desarrollo integrado con un lenguaje de programación propio.

Ejemplos de lo que se puede hacer:

Usage Guide

Usage Guide : A simple example

La forma más sencilla de crear una figura con ejes es utilizando pyplot.subplots.

Luego podemos usar Axes.plot para dibujar algunos datos en los ejes:



matplotlib.pyplot.pie

matplotlib.pyplot.pie : Basic pie chart

import matplotlib.pyplot as plt # Pie chart, where the slices will be ordered and plotted counter-clockwise: labels = 'Frogs', 'Hogs', 'Dogs', 'Logs' sizes = [15, 30, 45, 10] explode = (0, 0.1, 0, 0) # only "explode" the 2nd slice (i.e. 'Hogs') fig1, ax1 = plt.subplots() ax1.pie(sizes, explode=explode, labels=labels, autopct='%1.1f%%', shadow=True, startangle=90) ax1.axis('equal') # Equal aspect ratio ensures that pie is drawn as a circle. plt.show()



Nota: observe los parámetros shadow y startangle, sobre todo startangle donde se indica en donde comenzar a partir las rebanadas.

matplotlib.pyplot.scatter

matplotlib.pyplot.scatter : Scatter plot

import numpy as np import matplotlib.pyplot as plt # Fixing random state for reproducibility np.random.seed(19680801) N = 50 x = np.random.rand(N) y = np.random.rand(N) colors = np.random.rand(N) area = (30 * np.random.rand(N))**2 # 0 to 15 point radii plt.scatter(x, y, s=area, c=colors, alpha=0.5) plt.show()

statistical data visualization

Seaborn es una biblioteca de visualización de datos de Python basada en matplotlib.

Proporciona una interfaz de alto nivel para dibujar gráficos estadísticos atractivos e informativos.

Seaborn es una biblioteca para hacer gráficos estadísticos en Python. Se basa en matplotlib y se integra estrechamente con las estructuras de datos de pandas.

Seaborn le ayuda a explorar y comprender sus datos. Sus funciones de trazado operan en marcos de datos y matrices que contienen conjuntos de datos completos y realizan internamente el mapeo semántico y la agregación estadística necesarios para producir gráficos informativos.

Su API declarativa y orientada a conjuntos de datos le permite centrarse en lo que significan los diferentes elementos de sus gráficos, en lugar de en los detalles de cómo dibujarlos.

import seaborn as sns # Load an example dataset tips = sns.load_dataset("tips") # Create a visualization sns.relplot( data=tips, x="total_bill", y="tip", col="time", hue="smoker", style="smoker", size="size", )

¿Qué es machine learning?

Machine learning es una forma de la IA que permite a un sistema aprender de los datos en lugar de aprender mediante la programación explícita.

Sin embargo, machine learning no es un proceso sencillo.

Conforme el algoritmo ingiere datos de entrenamiento, es posible producir modelos más precisos basados en datos.

Un modelo de machine learning es la salida de información que se genera cuando entrena su algoritmo de machine learning con datos.

Después del entrenamiento, al proporcionar un modelo con una entrada, se le dará una salida.

Por ejemplo, un algoritmo predictivo creará un modelo predictivo. A continuación, cuando proporcione el modelo predictivo con datos, recibirá un pronóstico basado en los datos que entrenaron al modelo.

Machine learning permite modelos a entrenar con conjuntos de datos antes de ser implementados.

Algunos modelos de machine learning están online y son continuos.

Este proceso iterativo de modelos online conduce a una mejora en los tipos de asociaciones hechas entre los elementos de datos.

Debido a su complejidad y tamaño, estos patrones y asociaciones podrían haber sido fácilmente pasados por alto por la observación humana.

Después de que un modelo ha sido entrenado, se puede utilizar en tiempo real para aprender de los datos.

Las mejoras en la precisión son el resultado del proceso de entrenamiento y la automatización que forman parte del machine learning.

Las técnicas de machine learning son necesarias para mejorar la precisión de los modelos predictivos.

Dependiendo de la naturaleza del problema empresarial que se está atendiendo, existen diferentes enfoques basados en el tipo y volumen de los datos.

Aprendizaje supervisado

En aprendizaje automático y minería de datos, el aprendizaje supervisado es una técnica para deducir una función a partir de datos de entrenamiento.

Los datos de entrenamiento consisten de pares de objetos: una componente del par son los datos de entrada y el otro, los resultados deseados.

El aprendizaje supervisado comienza típicamente con un conjunto establecido de datos y una cierta comprensión de cómo se clasifican estos datos.

El aprendizaje supervisado tiene la intención de encontrar patrones en datos que se pueden aplicar a un proceso de analítica.

Estos datos tienen características etiquetadas que definen el significado de los datos.

Por ejemplo, se puede crear una aplicación de machine learning con base en imágenes y descripciones escritas que distinga entre millones de animales.

El objetivo del aprendizaje supervisado es el de crear una función capaz de predecir el valor correspondiente a cualquier objeto de entrada válida después de haber visto una serie de ejemplos, los datos de entrenamiento.

Para ello, tiene que generalizar a partir de los datos presentados a las situaciones no vistas previamente

El aprendizaje no supervisado se utiliza cuando el problema requiere una cantidad masiva de datos sin etiquetar.

Por ejemplo, las aplicaciones de redes sociales, tales como Twitter, Instagram y Snapchat, tienen grandes cantidades de datos sin etiquetar.

La comprensión del significado detrás de estos datos requiere algoritmos que clasifican los datos con base en los patrones o clústeres que encuentra.

El aprendizaje no supervisado lleva a cabo un proceso iterativo, analizando los datos sin intervención humana.

Se utiliza con la tecnología de detección de spam en e-mails. Existen demasiadas variables en los e-mails legítimos y de spam para que un analista etiquete una cantidad masiva de e-mail no solicitado.

En su lugar, los clasificadores de machine learning, basados en clustering y asociación, se aplican para identificar e-mail no deseado.

El aprendizaje de refuerzo es un modelo de aprendizaje conductual.

El algoritmo recibe retroalimentación del análisis de datos, conduciendo el usuario hacia el mejor resultado.

El aprendizaje de refuerzo difiere de otros tipos de aprendizaje supervisado, porque el sistema no está entrenado con el conjunto de datos de ejemplo.

Más bien, el sistema aprende a través de la prueba y el error.

Por lo tanto, una secuencia de decisiones exitosas conduce al fortalecimiento del proceso,

porque es el que resuelve el problema de manera más efectiva.

El deep learning es un método específico de machine learning que incorpora las redes neuronales en capas sucesivas para aprender de los datos de manera iterativa.

El deep learning es especialmente útil cuando se trata de aprender patrones de datos no estructurados.

Las redes neuronales complejas de deep learning están diseñadas para emular cómo funciona el cerebro humano, así que las computadoras pueden ser entrenadas para lidiar con abstracciones y problemas mal definidos.

Las redes neuronales y el deep learning se utilizan a menudo en el reconocimiento de imágenes, voz y aplicaciones de visión de computadora.

Aplicación de machine learning a las necesidades empresariales

Machine learning requiere que el correcto conjunto de datos se aplique a un proceso de aprendizaje.

Una organización no necesita de big data para utilizar las técnicas del machine learning; sin embargo, el big data puede ayudar a mejorar la precisión de los modelos de machine learning.

Con big data, ahora es posible virtualizar los datos para que se puedan almacenar de la forma más eficiente y eficaz en función de los costos, ya sea en el entorno local o en la nube.

Además, las mejoras en la velocidad y confiabilidad en la red han eliminado otras limitaciones físicas asociadas con la gestión de cantidades masivas de datos a una velocidad aceptable.

Añada a esto el impacto de los cambios en el precio y la sofisticación de la memoria de computadora y ahora es posible imaginar cómo las compañías pueden aprovechar los datos de formas que hubieran sido inconcebibles hace sólo cinco años.

La ventaja de machine learning es que es posible aprovechar algoritmos y modelos para predecir resultados.

Es importante asegurarse de que los científicos de datos que realizan el trabajo usen los algoritmos correctos, asimilando los datos más apropiados (que sean precisos y limpios) y utilizando los mejores modelos de rendimiento.

Si todos estos elementos se reúnen, es posible entrenar continuamente al modelo y explotar los resultados aprendiendo de los datos.

La automatización de este proceso de modelado, entrenamiento del modelo y pruebas conduce a predicciones precisas para dar soporte a los cambios empresariales.