Python

Pordavid 
Python:
------

1. Como ejecutar python en linux:

- Abrir una terminal
- Verificar la instalación de python: python3 --version
- Ejecutar un script de python: 
	* Navega hasta el archivo: cd /ruta/del/archivo
	* Ejecuta el archivo con el comando python3: python3 mi_archivo.py
- Hacer el script ejecutable (opcional): Si deseas ejecutar el script sin el comando 
  python3 primero debes darle permisos de ejecucion:
	chmod +x mi_archivo.py 
	Y luego lo ejecutas directamente: ./mi_archivo.py

2. Tipos de variables:
---------------------

- Numeros enteros: edad = 25
- Flotantes (float): precio = 19.99 
- Cadenas (str) secuencia de caracteres: nombre = "Juan"
- Booleanos (bool), valores de verdad ( True o False): es_estudiante = True
- Listas (list), coleciones ordenadas y mutables de elementos:
	frutas = ["manzana", "banana", "cereza"]
- Tuplas (tuple), coleciones ordenadas e inmutables de elementos:
	coordenadas = (10, 20)
- Diccionarios (dict), colecciones de pares clave-valor:
	estudiante = { "nombre": "Ana", "edad": 22}
- Conjuntos (set), colecciones desordenadas de elementos unicos:
	numeros_unicos = {1,2,3,4,5}

3. Operadores: 
-------------

- Aritméticos: +, -, *, /, %, **
- Relacionales: >, <, ==, >=, <=, != 
- Lógicos: and, or, not
- Pertenencia: in, not in
- Identidad: is, is not

4. Estructuras de control:
-------------------------

Las estructuras de control en Python son fundamentales para dirigir el flujo de ejecución de un programa. Aquí tienes un resumen de las principales estructuras de control:

- Condicionales:

if, elif, else: Permiten ejecutar bloques de código basados en condiciones específicas.
Python

if condition:
    # código si la condición es verdadera
elif another_condition:
    # código si la otra condición es verdadera
else:
    # código si ninguna condición es verdadera 

- Bucles:

for: Se utiliza para iterar sobre una secuencia (como una lista, tupla, diccionario, conjunto o cadena).
Python

for element in sequence:
    # código a ejecutar en cada iteración

while: Repite un bloque de código mientras una condición sea verdadera.

while condition:
    # código a ejecutar mientras la condición sea verdadera

Control de bucles:
break: Termina el bucle prematuramente.
continue: Salta a la siguiente iteración del bucle.
pass: No hace nada, se usa como un marcador de posición.

5. Funciones:
------------

def nombre_funcion(parametros):
	# bloque de codigo
	return valor # opcional

- Ejemplo:

def saludar():
    print("¡Hola, mundo!")

saludar()  # Llama a la función y muestra "¡Hola, mundo!"


- Parámetros y Valores de Retorno

Las funciones pueden aceptar parámetros y devolver valores. Aquí tienes un ejemplo con
parámetros y un valor de retorno:

def sumar(a, b):
    return a + b

resultado = sumar(3, 5)
print(resultado)  # Muestra 8

- Parámetros por Defecto

Puedes definir valores por defecto para los parámetros. Si no se proporciona un argumento,
se usará el valor por defecto.

def saludar(nombre="Mundo"):
    print(f"¡Hola, {nombre}!")

saludar()  # Muestra "¡Hola, Mundo!"
saludar("Ada")  # Muestra "¡Hola, Ada!"

Parámetros con Nombre
Puedes pasar argumentos utilizando el nombre del parámetro, lo que permite mayor 
flexibilidad en el orden de los argumentos.

def presentar(nombre, edad):
    print(f"Me llamo {nombre} y tengo {edad} años.")

presentar(edad=30, nombre="Juan")  # Muestra "Me llamo Juan y tengo 30 años."

Funciones Anónimas (Lambdas)
Python también permite definir funciones anónimas usando la palabra clave lambda. Estas 
funciones son útiles para operaciones simples y rápidas.

multiplicar = lambda x, y: x * y
print(multiplicar(3, 4))  # Muestra 12

6. Manejo de Errores:
--------------------

- Errores:
----------
Los errores detienen la ejecución del programa y tienen varias causas. Para poder estudiarlos mejor vamos a provocar algunos intencionadamente.

Errores de sintaxis
Identificados con el código SyntaxError, son los que podemos apreciar repasando el código, por ejemplo al dejarnos de cerrar un paréntesis:


print("Hola"

File "<ipython-input-1-8bc9f5174855>", line 1
    print("Hola"
                ^
SyntaxError: unexpected EOF while parsing
Errores de nombre
Se producen cuando el sistema interpreta que debe ejecutar alguna función, método... pero no lo encuentra definido. Devuelven el código NameError:


pint("Hola")

<ipython-input-2-155163d628c2> in <module>()
----> 1 pint("Hola")

NameError: name 'pint' is not defined
La mayoría de errores sintácticos y de nombre los identifican los editores de código antes de la ejecución, pero existen otros tipos que pasan más desapercibidos.

Errores semánticos
Estos errores son muy difíciles de identificar porque van ligados al sentido del funcionamiento y dependen de la situación. Algunas veces pueden ocurrir y otras no.

La mejor forma de prevenirlos es programando mucho y aprendiendo de tus propios fallos, la experiencia es la clave. Veamos un par de ejemplos:

Ejemplo pop() con lista vacía

Si intentamos sacar un elemento de una lista vacía, algo que no tiene mucho sentido, el programa dará fallo de tipo IndexError. Esta situación ocurre sólo durante la ejecución del programa, por lo que los editores no lo detectarán:


l = []
l.pop()

<ipython-input-6-9e6f3717293a> in <module>()
----> 1 l.pop()

IndexError: pop from empty list
Para prevenir el error deberíamos comprobar que una lista tenga como mínimo un elemento antes de intentar sacarlo, algo factible utilizando la función len():


l = []

if len(l) > 0:
    l.pop()
Ejemplo lectura de cadena y operación sin conversión a número

Cuando leemos un valor con la función input(), éste siempre se obtendrá como una cadena de caracteres. Si intentamos operarlo directamente con otros números tendremos un fallo TypeError que tampoco detectan los editores de código:


n = input("Introduce un número: ")

print("{}/{} = {}".format(n,m,n/m))

Introduce un número: 4

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-12-85bb893ab3e3> in <module>()
----> 1 print("{}/{} = {}".format(n,m,n/m))

TypeError: unsupported operand type(s) for /: 'str' and 'int'
Como ya sabemos este error se puede prevenir transformando la cadena a entero o flotante:


n = float(input("Introduce un número: "))
m = 4
print("{}/{} = {}".format(n,m,n/m))

Introduce un número: 10
10.0/4 = 2.5
Sin embargo no siempre se puede prevenir, como cuando se introduce una cadena que no es un número:


n = float(input("Introduce un número: "))
m = 4
print("{}/{} = {}".format(n,m,n/m))

Introduce un número: aaa

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-14-c0e7fd4a26a9> in <module>()
----> 1 n = float(input("Introduce un número: "))
    2 m = 4
    3 print("{}/{} = {}".format(n,m,n/m))

ValueError: could not convert string to float: 'aaa'
Como podéis suponer, es difícil prevenir fallos que ni siquiera nos habíamos planteado que podían existir. Por suerte para esas situaciones existen las excepciones.


- Excepciones:
-------------

Las excepciones son bloques de código que nos permiten continuar con la ejecución de un programa pese a que ocurra un error.

Siguiendo con el ejemplo de la lección anterior, teníamos el caso en que leíamos un número por teclado, pero el usuario no introducía un número:


n = float(input("Introduce un número: "))
m = 4
print("{}/{} = {}".format(n,m,n/m))

Introduce un número: aaa

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-14-c0e7fd4a26a9> in <module>()
----> 1 n = float(input("Introduce un número: "))
    2 m = 4
    3 print("{}/{} = {}".format(n,m,n/m))

ValueError: could not convert string to float: 'aaa'
Bloques try - except
Para prevenir el fallo debemos poner el código propenso a errores en un bloque try y luego encadenar un bloque except para tratar la situación excepcional mostrando que ha ocurrido un fallo:


try:
    n = float(input("Introduce un número: "))
    m = 4
    print("{}/{} = {}".format(n,m,n/m))
except:
    print("Ha ocurrido un error, introduce bien el número")

Introduce un número: aaa
Ha ocurrido un error, introduce bien el número
Como vemos esta forma nos permite controlar situaciones excepcionales que generalmente darían error y en su lugar mostrar un mensaje o ejecutar una pieza de código alternativo.

Podemos aprovechar las excepciones para forzar al usuario a introducir un número haciendo uso de un bucle while, repitiendo la lectura por teclado hasta que lo haga bien y entonces romper el bucle con un break:


while(True):
    try:
        n = float(input("Introduce un número: "))
        m = 4
        print("{}/{} = {}".format(n,m,n/m))
        break  # Importante romper la iteración si todo ha salido bien
    except:
        print("Ha ocurrido un error, introduce bien el número")

Introduce un número: aaa
Ha ocurrido un error, introduce bien el número
Introduce un número: sdsdsd
Ha ocurrido un error, introduce bien el número
Introduce un número: sdsdsd
Ha ocurrido un error, introduce bien el número
Introduce un número: sdsd
Ha ocurrido un error, introduce bien el número
Introduce un número: 10
10.0/4 = 2.5
Bloque else
Es posible encadenar un bloque else después del except para comprobar el caso en que todo funcione correctamente (no se ejecuta la excepción).

El bloque else es un buen momento para romper la iteración con break si todo funciona correctamente:


while(True):
    try:
        n = float(input("Introduce un número: "))
        m = 4
        print("{}/{} = {}".format(n,m,n/m))
    except:
        print("Ha ocurrido un error, introduce bien el número")
    else:
        print("Todo ha funcionado correctamente")
        break  # Importante romper la iteración si todo ha salido bien

Introduce un número: 10
10.0/4 = 2.5
Todo ha funcionado correctamente
Bloque finally
Por último es posible utilizar un bloque finally que se ejecute al final del código, ocurra o no ocurra un error:


while(True):
    try:
        n = float(input("Introduce un número: "))
        m = 4
        print("{}/{} = {}".format(n,m,n/m))
    except:
        print("Ha ocurrido un error, introduce bien el número")
    else:
        print("Todo ha funcionado correctamente")
        break  # Importante romper la iteración si todo ha salido bien
    finally:
        print("Fin de la iteración") # Siempre se ejecuta

Introduce un número: aaa
Ha ocurrido un error, introduce bien el número
Fin de la iteración
Introduce un número: 10
10.0/4 = 2.5
Todo ha funcionado correctamente
Fin de la iteración

- Excepciones múltiples:
-----------------------
En una misma pieza de código pueden ocurrir muchos errores distintos y quizá nos interese actuar de forma diferente en cada caso.

Para esas situaciones algo que podemos hacer es asignar una excepción a una variable.

De esta forma es posible analizar el tipo de error que sucede gracias a su identificador:


try:
    n = input("Introduce un número: ")  # no transformamos a número
    5/n
except Exception as e:  # guardamos la excepción como una variable e
    print("Ha ocurrido un error =>", type(e).__name__)

Introduce un número: 10
Ha ocurrido un error =>  TypeError
Cada error tiene un identificador único que curiosamente se corresponde con su tipo de dato. Aprovechándonos de eso podemos mostrar la clase del error utilizando la sintaxis:


print( type(e) )

<class 'TypeError'>
Es similar a conseguir el tipo (o clase) de cualquier otra variable o valor literal:


print(type(1))
print(type(3.14))
print(type([]))
print(type(()))
print(type({}))

<class 'int'>
<class 'float'>
<class 'list'>
<class 'tuple'>
<class 'dict'>
Como vemos siempre nos indica eso de "class" delante. Eso es porque en Python todo son clases, pero hablaremos de este concepto más adelante. Lo importante ahora es que podemos mostrar solo el nombre del tipo de dato (la clase) consultando su propiedas especial name de la siguiente forma:


print( type(e).__name__)
print(type(1).__name__)
print(type(3.14).__name__)
print(type([]).__name__)
print(type(()).__name__)
print(type({}).__name__)

TypeError
int
float
list
tuple
dict
Gracias a los identificadores de errores podemos crear múltiples comprobaciones, siempre que dejemos en último lugar la excepción por defecto Excepcion que engloba cualquier tipo de error (si la pusiéramos al principio las demas excepciones nunca se ejecutarían):


try:
    n = float(input("Introduce un número divisor: "))
    5/n
except TypeError:
    print("No se puede dividir el número entre una cadena")
except ValueError:
    print("Debes introducir una cadena que sea un número")
except ZeroDivisionError:
    print("No se puede dividir por cero, prueba otro número")
except Exception as e:
    print("Ha ocurrido un error no previsto", type(e).__name__ )

Introduce un número divisor: 0
No se puede dividir por cero, prueba otro número

- Invocación de excepciones:
---------------------------
En algunas ocasiones quizá nos interesa llamar un error manualmente, ya que un print común no es muy elegante:


def mi_funcion(algo=None):
    if algo is None:
        print("Error! No se permite un valor nulo (con un print)")

mi_funcion()

Error! No se permite un valor nulo (con un print)
Instrucción raise
Gracias a raise podemos lanzar un error manual pasándole el identificador. Luego simplemente podemos añadir un except para tratar esta excepción que hemos lanzado:


def mi_funcion(algo=None):
    try:
        if algo is None:
            raise ValueError("Error! No se permite un valor nulo")
    except ValueError:
        print("Error! No se permite un valor nulo (desde la excepción)")

mi_funcion()

Error! No se permite un valor nulo (desde la excepción)

7. Entradas y Salidas:
---------------------

- Entrada por teclado:
---------------------

Entrada por teclado
Ya conocemos la función input() que lee una cadena por teclado. Su único inconveniente es que debemos transformar el valor a numérico si deseamos hacer operaciones con él:


decimal = float( input("Introduce un número decimal con punto: ") )

Introduce un número decimal con punto: 3.14
Una forma interesante de leer varios valores es almacenar los datos en una lista e irlos añadiendo ahí para poderlos manipular en grupo:

Copiado al portapapeles
valores = []
print("Introduce 3 valores")
for x in range(3):
    valores.append( input("Introduce un valor: ") )
print(valores)

Introduce 3 valores
Introduce un valor: 10
Introduce un valor: sdkjsdk
Introduce un valor: skdjs
['10', 'sdkjsdk', 'skdjs']

- Entrada por script:
--------------------

Scripts con argumentos
Para poder enviar información a un script y manejarla, tenemos que utilizar la librería de sistema sys. En ella encontraremos la lista argv que almacena los argumentos enviados al script. Cread el siguiente script y ejecutadlo:


import sys
print(sys.argv)

python argumentos.py

['argumentos.py']
Al ejecutarlo veréis que devuelve una lista con una cadena que contiene el nombre del script. Quedaros con la idea pues, de que el primer argumento de la lista sys.argv (sys.argv[0]) es el propio nombre del script.

Ahora intentad ejecutarlo de nuevo pasando algunos valores como números y cadenas de texto entre comillas dobles, todo separado por espacios:


python argumentos.py 100 "Hola" 3.14

['argumentos.py', '100', 'Hola', '3.14']
Cada valor que enviamos al script durante la llamada se llama argumento e implica una forma de entrada de datos alternativa sin usar el input().

El siguiente ejemplo es un script que recibe dos argumentos: un texto y un número entero. Lo que hace es imprimir la cadena de texto tantas veces como le indiquemos en el número. Tomaos el tiempo necesario para analizar y entender cada línea:


import sys

# Comprobación de seguridad, ejecutar sólo si se reciben 2 argumentos reales
if len(sys.argv) == 3:
    texto = sys.argv[1]
    repeticiones = int(sys.argv[2])
    for r in range(repeticiones):
        print(texto)
else:
    print("Error - Introduce los argumentos correctamente")
    print('Ejemplo: escribir_lineas.py "Texto" 5')

python escribir_lineas.py "Hola Mundo!!!" 5

Hola Mundo!!!
Hola Mundo!!!
Hola Mundo!!!
Hola Mundo!!!
Hola Mundo!!!

- Salida por pantalla:
---------------------
La función print() es la forma general de mostrar información por pantalla. Generalmente podemos mostrar texto y variables separándolos con comas:


v = "otro texto"
n = 10

print("Un texto",v,"y un número",n)

Un texto otro texto y un número 10
El método .format()
Es una funcionalidad de las cadenas de texto que nos permite formatear información en una cadena (variables o valores literales) cómodamente utilizando identificadores referenciados:


c = "Un texto '{}' y un número '{}'".format(v,n)
print(c)

Un texto 'otro texto' y un número '10'
También podemos referenciar a partir de la posición de los valores utilizando índices:


print( "Un texto '{1}' y un número '{0}'".format(v,n) )
print(c)

Un texto '10' y un número 'otro texto'
O podemos utilizar identificador con una clave y luego pasarlas en el format:


print( "Un texto '{v}' y un número '{n}'".format(n=n,v=v) )

Un texto 'otro texto' y un número '10'

print("{v},{v},{v}".format(v=v))

otro texto,otro texto,otro texto

- formateo simplificado:

La nueva sintaxis nos permite ahorrarnos el método:


nombre = "Héctor"
texto = f"Hola {nombre}"
print(texto)

Hola Héctor
Sólo tenemos que indicar f antes de la cadena y sustituir las variables por sus nombre.

Publicaciones Similares

  • Manual apache2

    Pordavid

    Version Para verificar la versión de Apache en Linux, puedes utilizar los siguientes comandos en la terminal, dependiendo de la distribución que estés utilizando: Esto proporcionará la misma información sobre la versión de Apache. Para obtener detalles desde el administrador de paquetes (usando el comando apt): 2. En distribuciones basadas en RHEL/Fedora/CentOS (como Fedora, CentOS, AlmaLinux y Rocky Linux): Instalacion Con…

  • Inteligencia Artificial

    Pordavid

    Introducción La inteligencia artificial (IA) ha emergido como una de las tecnologías más revolucionarias del siglo XXI. Desde sus inicios como una idea futurista hasta convertirse en una realidad palpable, la IA ha demostrado tener un impacto significativo en diversas áreas de la sociedad. Su crecimiento exponencial ha sido impulsado por avances en el aprendizaje…

  • Reverse shell, Bind shell y Foward shell

    Pordavid

    En esta clase, veremos las diferencias entre Reverse Shell, Bind Shell y Forward Shell: Reverse Shell: Es una técnica que permite a un atacante conectarse a una máquina remota desde una máquina de su propiedad. Es decir, se establece una conexión desde la máquina comprometida hacia la máquina del atacante. Esto se logra ejecutando un…

  • La Grid de Bootstrap

    Pordavid

    El sistema de grid de Bootstrap es una de sus características más potentes. Te permite estructurar contenido de manera flexible y responsiva usando contenedores, filas, columnas y algunas opciones adicionales como offset. Aquí te explico cada componente con ejemplos: 1. Contenedor (container) El contenedor es el elemento principal que encapsula el contenido de tu grid….

  • |

    Implementación de un Chat tipo mIRC

    Pordavid

    Implementación de un Chat Tipo mIRC con next-mIRC 1. Descargar el Proyecto Primero, necesitas clonar el repositorio de next-mIRC desde GitHub: bash 2. Instalar Dependencias Asegúrate de tener Docker instalado en tu sistema. Luego, instala las dependencias necesarias: bash 3. Construir la Imagen Docker Construye la imagen Docker para el proyecto: bash 4. Ejecutar el…

  • |

    PHP

    Pordavid

    PHP está diseñado para ser fácil de aprender y potente en su aplicación, lo que lo convierte en una opción popular para desarrolladores de todos los niveles. Aquí tienes algunos aspectos básicos: Comentarios: Puedes agregar comentarios en tu código PHP para hacerlo más legible. Los comentarios de una sola línea comienzan con //, mientras que los comentarios…

580 comentarios

  39. Thanks for oones marvelous posting! I quiote enjjoyed reading it, youu mitht be a great author.
    I will be sure to bookmark yyour blog and definitesly will comje
    back in thee future. I wajt too encourae yoou to ultiumately continue ypur great writing,
    have a nie weekend!

    Responder

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *