Saltar a contenido

2021

  • en Sistemas
  • 5 minutos de lectura

¿Qué es la conversión de números?

En informática tendremos que enfrentarnos con varios problemas que requieren de soluciones distintas haciendo uso de la capacidad resolutiva para según que problemas con los que nos podamos encontrar en el ámbito de sistemas, haciendo uso de algoritmos para sacarnos de apuros en desarrollo Web, e incluso, haciendo un proceso de descartes en base a pruebas de rendimiento.

Aquí todo es posible, sin embargo, también debemos aprender las unidades básicas con la que las máquinas trabajan para enviar información a bajo nivel, obtener un color para nuestros desarrollos Web...etc Todo esto lo aprenderemos aquí.

Binario

Los números binarios son aquellos que están comprendidos entre 0 y 1 utilizando como base el 2. Esto representa la condición eléctrica, es decir, 0 es apagado y 1 es encendido.

Binario => Decimal BIN->DEC

Para convertir de binario a decimal tenemos dos formas de hacerlo.

  • Mediante el uso de una tabla exponencial
  • Tabla de exponentes

Mediante posición

Para convertir mediante posición, lo único que deberemos hacer, es saber en qué posición tenemos cada número y utilizar las potencias.

110101(2) => Decimal

((1*2⁵)+(1*2⁴)+(0*2³)+(1*2²)+(0*2¹)+(1*2⁰)) =
((1*2⁵)+(1*2⁴)+(1*2²)+(1*2⁰)) = 53(10)

53(10) es nuestro número decimal.

Tabla de exponentes

Dibujamos una tabla en relación al número que creemos que podamos obtener.

128 64 32 16 8 4 2 1
2⁷ 2⁶ 2⁵ 2⁴ 2³ 2² 2¹ 2⁰

Y en base al número que nos den, comenzamos a comparar de menor a mayor. Por ejemplo:

Nº 128 64 32 16 8 4 2 1
105 0 1 1 0 1 0 0 1

Binario => Hexadecimal

Tenemos que tener en cuenta la siguiente equivalencia:

Hexadecimal Binario
0 0000
1 0001
2 0010
3 0011
4 0100
5 0101
6 0110
7 0111
8 1000
9 1001
A 1010
B 1011
C 1100
D 1101
E 1110
F 1111

Para convertir tan solo necesitaremos traducir cifra por cifra en base a esta tabla. Por ejemplo: 1010111101100100

1010 = A
1111 = F
0110 = 6
0100 = 4

Nuestro número es: AF64

Binario -> Octal

Tenemos que tener presente la siguiente equivalencia:

Decimal Binario
0 000
1 001
2 010
3 011
4 100
5 101
6 110
7 111

El octal solo hace uso de 3 bits, y no de 4 como el decimal o hexadecimal. Tomaremos los 3 primeros bits y los separamos para hacer la conversión.

1 010 010 111(2) = x(8)

1 010 111 => Vemos como el 1 está solo, por ello, le añadimos 2 ceros para normalizarlo.
001 010 111.

Nuestro número es: 127(8)

Decimal

Son números comprendidos entre 0 y 9, hacen uso de base 10. Estos se suelen utilizar mucho para representar la numeración IPv4, obtener un color para aplicarlo en desarrollo Web mediante la función rgb/rgba()...etc

Decimal => Binario DEC->BIN

Para convertir de binario a decimal tenemos dos formas de hacerlo.

  • Mediante división
  • Tabla exponencial

División

Para convertir de decimal a binario, simplemente tenemos que tener en cuenta el resto de la división, ignorar los decimales y continuar dividiendo el número del cociente hasta que ya no pueda dividirse más. Para reconstruir el número, se seleccionan de derecha a izquierda.

Por ejemplo: 

362|2 = 0
181|2 = 1
 90|2 = 0
 45|2 = 1
 22|2 = 0
 11|2 = 1
  5|2 = 1
  2|2 = 0
  0|2 = 1

101101010

Tabla de exponentes

Dibujamos una tabla en relación al número que creemos que podamos obtener.

128 64 32 16 8 4 2 1
2⁷ 2⁶ 2⁵ 2⁴ 2³ 2² 2¹ 2⁰

Y en base al número que nos den, comenzamos a comparar de menor a mayor. Por ejemplo:

Nº 128 64 32 16 8 4 2 1
105 0 1 1 0 1 0 0 1

Decimal -> Hexadecimal

Dividimos el número entre 16 utilizamos el cociente para seguir dividiendo sin utilizar los decimales resultantes. Posteriormente, para obtener el resto, se multiplica el decimal obtenido de la división por 16 que es la base para obtener el resto.

Por ejemplo: 2937(10) -> x(16)

2937|16 = 183.5625 -> Resto = 0.5625*16 = 9
 183|16 = 11.4375 -> Re = 0.4375*16 = 7
  11|16 = 0.6875 -> Re = 0.6875*16 = B

Con lo que nuestro nº es: B79(16)

Decimal -> Octal

Se divide el número decimal entre 8, se desestiman los decimales, y el último número que ya no puede ser divisible se queda tal cual como resto formando parte del nº. Se lee de derecha hacia la izquierda.

210(10) = x(8)

210|8 = Resto =2
 26|8 = Re = 2
  3|8 = Re =3

Nuestro número es: 322.

Hexadecimal

Estos números son muy utilizados sobre todo cuando queremos manipular cierta información de archivos, contemplan un rango entre 0 y F, siendo F el número 15, hace uso de base 16.

Hexadecimal => Decimal

Para convertir de hexadecimal a decimal

Utilizamos las posiciones de los números y los multiplicamos por el resultado de su base.

B79(16) = x(12)

B*16² + 7*16¹ + 9*16⁰ =
11*256 + 7*16 + 9*1 =
2816+112+9 = 2937(10)

Hexadecimal => Binario

Tenemos que tener en cuenta la siguiente equivalencia:

Hexadecimal Binario
0 0000
1 0001
2 0010
3 0011
4 0100
5 0101
6 0110
7 0111
8 1000
9 1001
A 1010
B 1011
C 1100
D 1101
E 1110
F 1111

Para convertir tan solo necesitaremos traducir cifra por cifra en base a esta tabla. Por ejemplo: A7F0

A = 1010
7 = 0111
F = 1111
0 = 0000

Nuestro número es: 1010011111110000

Hexadecimal -> Octal

Realizar este proceso de conversión no es un método directo. Primero hay que traducir de HEX->BIN y luego de BIN->OCT para obtener el valor.

E67(16) = x(8)

E(16) = 1110(2)
6(16) = 0110(2)
7(16) = 0111(2)

Nº convertido= 111001100111

Una vez obtenido el binario, lo pasamos a octal.

111001100111(2) = x(8)

111 001 100 111 = 7147(8)

Nuestro número es 7147(8)

Octal

Útil pero menos visto, nos permite obtener un número comprendido entre 0-7, hace uso de base 8.

Octal -> Decimal

Se tiene en cuenta la posición de la cifra, ya que luego se multiplica por su base, y a su vez, la base se multiplica por sí misma tantas veces tenga n en el exponente.

7147(8) = x(10)

7*8³ + 1*8² + 4*8¹ + 7*8⁰ = 3584 + 64 + 32 + 7

Nuestro número es: 3,687

Octal -> Binario

Básicamente utilizamos 3 bits por dígito, hay que tener en cuenta la siguiente equivalencia:

Tenemos que tener presente la siguiente equivalencia:

Decimal Binario
0 000
1 001
2 010
3 011
4 100
5 101
6 110
7 111

7420(8) -> x(2)

7 = 111
4 = 100
2 = 010
0 = 000

Nuestro número es: 111100010000(2)

Octal -> Hexadecimal

Como hemos dicho anteriormente, es un proceso que no se hace directo y hay que hacer uso del paso anterior para obtener el número hexadecimal.

7456(8) -> x(2)

7 = 111
4 = 100
5 = 101
6 = 110

Nº binario: 111100101110

Para obtener el número hexadecimal, bastará con separar 4 bits los dígitos del nº binario.

1111 0010 1110(2) -> x(16)

1111 = F
0010 = 2
1110 = E

Nuestro número es: F2E

Finalizando

¡Espero que aprendáis mucho! Al principio puede costar, pero con la práctica terminas haciendo las operaciones casi al instante.

¡Un saludo!

Fuentes

  • en Linux
  • 2 minutos de lectura

Conversor HDMI-VGA Aukey

Hemos adquirido a través de Amazon, un conversor HDMI-VGA debido a que tenemos un portátil que no tiene toma VGA, solo un puerto HDMI y 2 micro-HDMI. Queriamos tan solo compartir lo bien que nos funciona este dispositivo y por lo que recomendamos su compra. 100% compatible con Linux. El conversor viene dentro de una caja de cartón fino, con un pequelo manual, una pegatina y el conversor con el puerto HDMI cubierto por un protector de plástico duro para evitar que se deteriore.

Aukey

Resultado de xrandr(1):

$ xrandr
Screen 0: minimum 8 x 8, current 3200 x 1080, maximum 32767 x 32767
DP-0 disconnected (normal left inverted right x axis y axis)
DP-1 disconnected (normal left inverted right x axis y axis)
eDP-1-1 connected primary 1920x1080+1280+0 (normal left inverted right x axis y axis) 344mm x 194mm
   1920x1080     60.02*+
   1400x1050     59.98  
   1280x1024     60.02  
   1280x960      60.00  
   1024x768      60.04    60.00  
   960x720       60.00  
   928x696       60.05  
   896x672       60.01  
   800x600       60.00    60.32    56.25  
   700x525       59.98  
   640x512       60.02  
   640x480       60.00    59.94  
   512x384       60.00  
   400x300       60.32    56.34  
   320x240       60.05  
DP-1-1 disconnected (normal left inverted right x axis y axis)
HDMI-1-1 connected 1280x1024+0+0 (normal left inverted right x axis y axis) 338mm x 270mm
   1280x1024     60.02*+  75.02  
   1920x1080     60.00    59.94  
   1280x960      60.00  
   1152x864      75.00  
   1280x720      60.00    59.94  
   1024x768      75.03    70.07    60.00  
   832x624       74.55  
   800x600       72.19    75.00    60.32    56.25  
   640x480       75.00    72.81    66.67    60.00    59.94  
   720x400       70.08
  • en Desarrollo
  • 6 minutos de lectura

Curso de Python - Controles de flujo, condicionales y bucles

Los controles de flujo se utilizan para definir cómo va actuar un script, aplicación... y qué va aplicarse inmediatamente después de evaluar la condición cuando se compare.

if

Esta estructura de control te permite evaluar una condición y ejecutar un trozo de código si la cumple.

>>> if (condición):
>>>  Bloque de código

if-else

El if-else es una estructura de control que permite hacer 1 cosa si se cumple la condicioń, si esta no se cumple, únicamente se ejecutará un bloque de código sin contemplar otras posibilidades.

if (condición 1):
  Bloque de código
else:
  Bloque de código

Veamos un ejemplo, Si tenemos un coche de marca Opel, emitirás un mensaje que diga "Tienes un Opel", si no es así, mostraremos un mensaje que diga que "No tienes un coche Opel".

>>> marca = "Citröen"
>>> if (marca == "Opel"):
>>>   print("Tienes un Opel")
>>> else:
>>>  print("No tienes un coche Opel")
'No tienes un coche Opel'

if-elif-else

¿Pero qué pasa cuando queremos comprobar múltiples condiciones? No podemos estar anidando if-else como si no hubiese un mañana uno dentro del otro. Para eso tenemos la estructura if-elif-else. Esta estructura nos permite hacer 1 cosa u otra en base a una condición, la cuál estará compuesto por uno o múltiples operadores como aritméticos, lógicos...

if (ondición 1):
  Bloque de código
elif (condición3):
  Bloque de código
elif (condición2):
  Bloque de código
else:
  Bloque de código

Veamos un ejemplo, Si tenemos un coche de marca Opel, emitirás un mensaje que diga "Tienes un Opel", si no es así, mostraremos un mensaje que diga que "No tienes un coche Opel".

>>> marca = "Citröen"
>>> if (marca == "Opel")
>>>   print("Tienes un Opel")
>>> elif (marca == "Citröen")
>>>   print("Tienes un coche Opel")
>>> elif (marca == "Audi"):
>>>   print("Tienes un Audi")
>>> else:
>>>   print("Tu marca de coche no está registrada")
Tienes un coche Citröen

Todo esto se puede complicar aún más haciendo uso de otros operadores y de otros if-elif-else anidados, por ejemplo, utilizaremos los operadores de comparación con lógicos tal que así:

>>> marca_coche = "Toyota"
>>> modelo_coche = "AE87"
>>> motor_coche = 1600
>>> if (marca_coche == "Toyota" and modelo_coche == "AE92"):
>>>   if (motor_coche == 1600):
>>>     print("Perfecto")
>>>   elif (motor_coche == 1400):
>>>     print("Bien")
>>>   elif (motor_coche == 1200):
>>>     print("Cuidado con las cuestas")
>>>   else:
>>>     print("Esto huele a chasis")
>>> elif (marca_coche == "Citröen" and modelo_coche == "Saxo"):
>>>   print("Enhorabuena, tienes un coche que pesa poco y corre mucho.")
>>> else:
>>>   print("Error 404, Tu coche no encontrado.")

Error 404, Tu coche no encontrado.

Este mensaje se produce porque en el primer condicional estamos esperando recibir el modelo AE92, y sin embargo, recibimos el AE87; como en la segunda condición (elif) requiere del modelo "Citröen" también queda descartado imprimiendo el mensaje "Error 404, Tu coche no encontrado.". No obstante, si cambiamos modelo_coche por AE92 y volvemos a ejecutar las sentencias, veremos que recibiremos el mensaje de: "Perfecto".

Bucle for

¿Qué ocurre si queremos recorrer una lista o generar múltiples ejecuciones de código? Pues evidetenmente con un if no nos vale, ya que solo nos permite validar una condicioń, y cuando la valide, esta dejará de ejecutarse.

for variable_interactiva in secuencia:
  Bloque código

¿Cómo funciona? En secuencia va una condición, podemos poner que recorra todos los valores de una lista y nos lo imprima por variable_interactiva.

>>> frutas = [ "Peras", "Manzanas", "Arándanos", "Pomelo"]
>>> for fruta in frutas:
>>>   print(fruta)
Peras
Manzanas
Arándanos
Pomelo

También se puede hacer ejecuciones por el tamaño de la lista:

>>> frutas = [ "Peras", "Manzanas", "Arándanos", "Pomelo"]
>>> for fruta in range(0 ,len(frutas)):
>>>   print("Esta es la posición", fruta,"de la fruta: ",frutas[fruta])
Esta es la posición 0 de la fruta:  Peras
Esta es la posición 1 de la fruta:  Manzanas
Esta es la posición 2 de la fruta:  Arándanos
Esta es la posición 3 de la fruta:  Pomelo

¿Cómo podemos hacer, que se hagan n ejecuciones para hacer tal cosa? Con la función range().

>>> for x in range(0,100):
>>>   print(x)
0
1
2
3
4
[... Corto aquí porque llega hasta 99 ...]

¿Por qué hasta 99 y no 100? Porque recordemos que el valor 0 es una posición que se cuenta, realmente es n - 1.

¿Cómo puedo romper una ejecución?

Tenemos el comando break que rompe la ejecución del código, por lo que me han enseñado, es mejor finalizar las cosas como tocan en vez de usar este tipo de "cañones". Pero que sepamos que lo podemos usar. Normalmente se usan cuando hay condicionales añadidos, esto no quiere decir que se siga ejecutándo el resto del programa que tengamos, solo se frena el bucle for que hemos invocado en nuestro fragmento de código.

>>> for x in range(0,100):
>>>   print(x)
>>>   if (x == 4):
>>>     break
0
1
2
3
4
[... Se para la ejecución ...]

Bucle while

Este bucle se repetirá hasta que la condición se cumpla. 

>>> while ( condicion ):
>>>   # Bloque de código

Un ejemplo sencillo puede ser:

>>> a = 1
>>> while a < 10:
>>>   print(a)
>>>   a += 2
0
2
4
6
8

break, continue, pass

Estas tres sentencias permiten modificar la interacción de los bucles. break: Rompe toda la ejecución de un bucle.

for x in range(0,10):
  if x == 5:
    break
  print(x)

Veremos que la ejecución cuando llega a 5 el bucle se para a pesar de que le hemos dicho que el bucle vaya de 0 a 10 e imprimirá como último valor 4.

continue: Se salta la ejecución en ese momento de la condición del bucle, pero sigue iterando el resto de elementos del bucle hasta finalizar.

for x in range(0,10):
  if x == 5:
    continue
  print(x)

En este caso, observamos que cuando detecte que x = 5, el valor 5 no se imprimirá, pero continuará realizando el resto de condición.

pass: No ejecuta nada y deja que continue el flujo del bucle.

for x in range(0,10):
  if x == 5:
    pass
  print(x)

Se ejecutará como si no existiera la palabra reservada pass.

Juego, Dragón VS Personaje

Un dragón nos estará golpeando hasta que nosotros matemos al dragón o el dragón nos mate a nosotros:

NOTA: Vamos a llamar al módulo random y lo llamaremos como TirarDados que más tarde utilizaremos el método .random() para generar números aleatorios que están comprendidos entre 0.n y 1.n y que, haciendo uso del método .round() aproximaremos el número a favor del 1 o del 0.

#!/usr/bin/env python3
#
# Juego elaborado por Álvaro Castillo
# GPLv2
#
from random import random as TirarDados
dragon_hp = 100
personaje_hp = 100
hit_dragon = 5
hit_personaje = 5

while True: 
  if personaje_hp == 0:
    print("Hemos ganado :)")
    break
  elif dragon_hp == 0:
    print("Ganó el Dragón :(")
    break
  else:
    pass
  dados=round(TirarDados())
  if ( dados == 0 ):
    dragon_hp -= hit_dragon
    print("¡Hemos golpeado al dragón!, le queda: ", dragon_hp, "de vida.")
  elif ( dados == 1):
   personaje_hp -= hit_personaje
   print("¡El dragón nos ha golpeado!, tenemos de vida:", personaje_hp,".")
  else:
   print("Hubo un fallo")

Este es el análisis resumido de este juego: 1. La vida de ambos duelistas están asignadas en una variable 2. El daño que quita cada uno de ellos también 3. La condición siempre es True por lo que siempre se ejecutará originando un bucle infinito infinityLoop 4. Si la vida de alguno de los duelistas llega a 0, se interrumpe el bucle usando break 5. La variable dados obtiene un número aproximado a 1|0 dependiendo lo que salga. 6. Hay un condicional que dice si datos=1 ataca el dragón, si dados=0 atacamos nosotros. 7. Haciendo uso de los operadores de asignación, restamos el valor de afección a la vida del duelista afectado y se imprime un mensaje indicando quién ha golpeado a quién y cuánta vida le queda al duelista contrario. 8. Se repite el proceso hasta llegar al punto 4

Dando como resultado algo parecido a esto:

¡El dragón nos ha golpeado!, tenemos de vida: 95 .
¡Hemos golpeado al dragón!, le queda:  95 de vida.
¡Hemos golpeado al dragón!, le queda:  90 de vida.
¡Hemos golpeado al dragón!, le queda:  85 de vida.
¡El dragón nos ha golpeado!, tenemos de vida: 90 .
¡Hemos golpeado al dragón!, le queda:  80 de vida.
¡Hemos golpeado al dragón!, le queda:  75 de vida.
[...]

Espero que os haya gustado, en ya hemos aprendido hacer un montón de cosas con estos cursos: * Qué es Python * Cómo declarar variables * Qué y cuáles son los tipos de datos * Cómo trabajar con los tipos de datos * Cómo utilizar módulos * Cómo elaborar un control de flujo

En las siguientes entregas hablaremos de más cosas que tengo preparadas como las funciones, cómo imprimir datos utilizando diversas formas de hacerlo y algunos ejercicios de ejemplo. ¡Espero que cómo siempre os haya gustado!

  • en Desarrollo
  • 2 minutos de lectura

Curso de Python - Encapsulamiento y polimorfismo

En este post haré una breve introducción a lo que es el encapsulamiento en Python y el poliformismo.

Encapsulamiento

Encapsular permite abstraer cierta información al mundo y mostrar solo aquella que interese. Por ejemplo, cuando enviamos un paquete por correos, el personal de correos no puede ver el contenido del paquete, pero si que puede ver el destinatario y el remitente, pudiendo identificar a las dos personas implicadas y saber sus direcciones de correo postal.

¿Cómo encapsular?

Para encapsular, básicamente tendremos que añadirle dos guiones bajos "_ __ _ " delante de la propiedad que queremos ocultar.

class A:
  self._propiedad = valor

Veamos un ejemplo:

class Persona:
  def __init__(self):
    self.nombre  = "Susana"
    self.__apellidos = "Bramura"
    self._tlfno = "777 777 777"

Carlos = Persona()

print(Carlos.apellidos)

Veremos un error parecido a este:

Traceback (most recent call last):
  File "main.py", line 9, in <module>
    print(Carlos.apellidos)
AttributeError: 'Persona' object has no attribute 'apellidos'

Y nos preguntaremos... Pero, si llamamos a Carlos.apellidos y nosotros hemos puesto: Carlos.__apellidos, ¿no sería más correcto para querer obtener el valor de los apellidos de la clase Persona? Bueno, aunque pensemos esto, si utilizamos __ igualmente dará el mismo error porque no se puede acceder desde fuera a una propiedad o método encapsulado.

print(Carlos.__apellidos)
Traceback (most recent call last):
  File "main.py", line 8, in <module>
    print(Carlos.__apellidos)
AttributeError: 'Persona' object has no attribute '__apellidos'

¿Cómo podemos acceder o modificar las variables, propiedades, o los métodos de ámbito privado?

Tendremos que crear métodos específicos que puedan acceder a esas variables, propiedades o métodos.

class A:
  # Constructor de clase
  def __init__(self):

    # Asignamos 20 a esta propiedad privada
    self.__propiedad = 20

  def __metodo(self):
    print("Soy un método privado.")

  # Soy un método público que leerá y ejecutará contenido privado.
  def mostrar(self):
    self.__metodo()
    print(self.__variable)

   def cambiar(self,propiedad):
     self.__propiedad = propiedad
     print("Esta es la nueva propiedad %i % (self.__propiedad))

# Instanciamos el objeto
obj = A()

# Ejecutamos el método público mostrar()
obj.mostrar()

# Modificamos el valor propiedad
obj.cambiar(300)

Polimorfismo

Es la capacidad que tiene un objeto para ser y poder ser otra cosa al mismo tiempo. Por ejemplo, un pájaro. Un pájaro puede ser un pingüino y un gorrión, ambos tienen propiedades en común como las patas, ojos, orejas; el color de las plumas, de los ojos, de los picos. También, tienen una serie de métodos similares como volar, poner huevos, comer, dormir... ¿Qué tienen en común todos ellos? Que son pájaros. Por lo tanto, un pájaro puede ser un gorrión o puede ser un pingüino al mismo tiempo sin perder lo que es su esencia, que es ser un pájaro.

# Creamos la clase Pájaro
class Pajaro:

  # Método volar
  def nadar(self):
    print("Puedo nadar.")

  def volar(self):
    print("Puedo volar.")

class Pinguino(Pajaro):
  def nadar(self):
    print("Puedo nadar.")

  def volar(self):
    print("No puedo volar.")

def ver_volar(birds)
  birds.volar()

gorrion=Pajaro()
pinguino=Pinguino()

# Este imprimirá que pude volar
ver_volar(gorrion)

# Este imprimirá que no puede volar
ver_volar(pinguino)
  • en Desarrollo
  • 2 minutos de lectura

Curso de Python - Fecha y hora

¿Qué tal mis queridos/as lectores/as? hace bastante tiempo que no redactaba en el blog, últimamente he estado ocupándome de tener un poco de tiempo para mí, como si tuviera unas mini vacaciones. Pero no importa, aquí vuelvo cargado de más conocimientos para todos.

En este pequeño post, aprenderás a trabajar con la fecha y la hora de una forma breve y sencilla antes de hacer la introducción a la programación por objetos o POO.

Fecha y hora

Hay un módulo llamado time que te permitirá trabajar con la fecha y la hora, estos son algunos métodos.

import time
print(time.ctime())

Devolverá:

Mon Apr 13 21:58:46 2020

No es muy práctico si quieres hacer otras cosas, como asignar una fecha y hora a un archivo que quieras crear, por suerte, puedes preformatear con .strftime().

import time
fecha_log = time.strftime("%d-%m-%Y_%H-%M-%S")
fecha_humano = time.strftime("%A %d %B %Y %H:%M:%S")

# Imprimirá una fecha como esta:
# 13-04-2020_22-23-06    
print(fecha_log)

# Imprimirá una fecha como esta:
# Monday 13 April 2020 22:23:06
print(fecha_humano)

Puedes ver más información sobre los parámetros para formatear aquí.

Este es un ejemplo de como almacenar el resultado del comando dmesg del sistema operativo Linux, y que se almacene el resultado en un archivo con la fecha preformateada.

import subprocess
dmesg = subprocess.Popen(["dmesg"], shell=False,stdout=subprocess.PIPE)

from time import strftime as ConvertirTiempoLog
fecha_log = ConvertirTiempoLog("%d-%m-%Y_%H-%M-%S")
archivo_log = "dmesg_log_%s.log" % (fecha_log)

with open(archivo_log,'w') as dmesg_log:
   dmesg_log.write(dmesg.stdout.read().decode('utf-8'))
   dmesg_log.close()

calendar

Muestra un calendario como el comando cal de Linux.

import calendar
calendar.month(2020,1)
# Nos mostrará:
    January 2020
Mo Tu We Th Fr Sa Su
       1  2  3  4  5
 6  7  8  9 10 11 12
13 14 15 16 17 18 19
20 21 22 23 24 25 26
27 28 29 30 31

Puedes hacer una combinación con el módulo time y calendar.

import time,calendar
anyo = int(time.strftime("%Y"))
mes = int(time.strftime("%m"))

#Imprimirá el calendario del año y me introducido.
print(calendar.month(anyo,mes))

O también puedes hacer que devuelva un calendario con valores específicos:

import calendar
anyo = int(input("Introduzca el año a consultar: "))
mes = int(input("Introduzca el mes: "))

#Imprimirá el calendario del año y me introducido.
print(calendar.month(anyo,mes))

Más información, en la documentación oficial.

  • en Desarrollo
  • 4 minutos de lectura

Curso de Python - Función print, type y ver los diferentes tipos de datos

Como hemos visto en la entrega anterior qué son los identificadores, vamos a trabajar un poco con algunos de ellos como las variables y explicaremos los tipos de datos haciendo uso de ellas.

¿Qué veremos en esta entrega? * Cómo imprimir de forma sencilla textos o valores almacenados en las variables con la función print() * Averiguar el tipo de dato con type() * Tpos de datos como son las cadenas, constantes, números enteros, coma flotante...

La función print()

Esta función se utiliza para imprimir valores por lo que nos podemos imaginar lo que podemos imprimir, resultados de funciones, valores asignados a variables, textos...etc.

print("Hello World")

Esta sentencia imprime en pantalla Hello World. Más adelante, veremos distintos usos de cómo utilizar esta función como por ejemplo, sustituciones de valores por variables...

La función type()

Esta función nos permite averiguar el tipo de dato que estamos tratando.

>>> type("Hello World")

O asignándolo en una variable y después imprimirlo:

>>> type("Hello World")

Esto nos devolverá un mensaje como: <class 'str'> indicando que es un str o cadena. Si probamos con un nº entero como el 2 nos devolverá <class 'int'>:

>>> type(2)

type() y print() son unas de las funciones más utilizadas, sobre todo para cuando tengamos que hacer depuración y revisar por qué en nuestro código hay cosas que no funcionan si estamos tratando con tipos de datos.

Tipos de datos en Python (Literals)

  • Cadenas o strings
  • Constantes
  • Númericos
  • Especiales

Cadenas o strings

Se forman encerrando un texto utilizando ( _ " _ ) ó ( '' ).

Por ejemplo: 

helloWorld = "Hello world"
helloWorld = 'Hello world'

Se puede definir cadenas con múltiples líneas:

helloWorldMessage = '''
Este es un mensaje para toda la civilización.
Todos(as) aquellos(as) que no se interesen por la historia,
estarán condenados(as) a repetir los mismos errores que se
cometieron en el pasado. '''

Obtener la primera letra de un str:

>>> mensaje = "Hola mundo"
>>> print(mensaje[0])
h

Obtener letras de un str a partir de un rango:

>>> mensaje = "Hola mundo"
>>> print(mensaje[0:4])
hola

Conseguir la posición de un str en un str:

>>> mensaje = "Hola mundo, me llamo sincorchetes y estamos en echemosunbitstazo.es"
>>> mensaje.find("me")
12

Si nos ponemos a contar (desde 0 siempre) caracter por caracter (incluyendo los espacios y ,), obtendremos el número 12.

Reemplazar un ´str´ dentro de un ´str´:

>>> mensaje = "Hola mundo, me llamo sincorchetes y estamos en echemosunbitstazo.es"
>>> mensaje.replace("sincorchetes","anonymous")
'Hola mundo, me llamo anonymous y estamos en echemosunbitstazo.es'

Separar un str cuando encuentre un caracter específico y devolver el resultado como una lista list:

>>> mensaje = "Hola mundo, me llamo sincorchetes y estamos en echemosunbitstazo.es"
>>> mensaje.split(" ")
['Hola',
 'mundo,',
 'me',
 'llamo',
 'sincorchetes',
 'y',
 'estamos',
 'en',
 'echemosunbitstazo.es']

Busca en el str un str y devuelve el nº de coincidencias:

>>> hi = "Hello"
>>> hi.count("l")
2

Convertir todos los caracteres de un str a mayúsculas:

>>> hi = "Hello"
>>> hi.upper()
'HELLO'

Convertir todos los caracteres de un str a minúsculas:

>>> hi = "HELLO"
>>> hi.lower()
'hello'

Convertir el primer caracter de un str en mayúscula:

>>> hi = "hello"
>>> hi.capitalize()
'Hello'

Obtener el valor máximo de un str:

>>> valor = "!#aBcDeFghI"
>>> max(valor)
'h'

Obtener el valor mínimo de un str:

>>> valor = "!#aBcDeFghI"
>>> min(valor)
'!'

Constantes

Las constantes como su nombre indica son valores que no se modificarán a lo largo de la vida del programa. Sin embargo en Python no se declaran a lo mejor como en otro lenguaje tipo PHP. Para hacerlo en Python, tenemos que respetar una forma de trabajo y sintaxis específicas. 1. Crea un archivo llamado constantes.py 2. Define en el variables, todas en mayúsculas y seguidas de " _ ". 3. Importa tu archivo en tu proyecto. 4. Llama a la constante.

Veamos un ejemplo: 1. Creamos el archivo constantes.py 2. Añadimos las siguientes variables:

IP_SERVIDOR = '127.0.0.1'
PUERTO_SERVIDOR = 3306
NOMBRE_USUARIO = 'sincorchetes'
PASS_USUARIO = 'Foo1234'
NOMBRE_DB = 'Foo'
  1. Creamos un archivo main.py
  2. Importamos el archivo y mencionamos a la constante.
import constantes
print(constantes.IP_SERVIDOR)

Veremos que tendremos una salida:

127.0.0.1

Así definiríamos una constante en Python.

Por otro lado, Python tiene unas constantes integradas que no estaría más echarles un vistazo, no son muchas, pero viene bien saberlas.

Números

Tenemos varios tipos de dato en Python como puede ser: * int * long (no se usa más en Python 3) * float * complex

int o números enteros

  • Este tipo de dato solo almacena números enteros (positivos y negativos, nada de comas, ni decimales, ni fracciones.
  • Este tipo de dato no contiene ninguna restricción por parte del número de bits en Python y puede expandirse el límite de la memoria disponible.
  • No se necesita ningún tipo de declaración especial para almacenar números muy largos.
>>> a = 1
>>> b = -2
>>> print(a - b)
3

float o número de coma flotante

Si necesitas utilizar decimales, este es el tipo de dato que buscar.

>>> x = 20.30
>>> y = -33.99
>>> z = 100.12
>>> print(x - y - z)
-45.83

complex o números complejos

Se utilizan para diferentes tipos de cálculos aplicados a la geometría, física... La definición en Python es a+bj, dónde a es el número que se encuentra representado en los números reales; bj es el número imaginario.

>>> a = 2+3j
>>> print(a)
2+3j

Tipos de datos especiales

Tenemos el valor None que viene a ser el valor null en otros lenguajes como SQL, se suele utilizar para declarar un campo con este valor ¡ojo, esto no quiere decir que esté vacío!

En las siguientes entregas veremos cómo trabajar con módulos y algunos operadores para empezar a prácticar operaciones aritméticas y de validación.

  • en Desarrollo
  • 4 minutos de lectura

Curso de Python - Herencia

Vamos a tratar un poco la herencia de que pueden tener los objetos, que es una de las características que tienen los objetos.

Herencia

Una de las propiedades que mencionamos que podían tener los objetos es la herencia, por lo que una clase hija puede contener propiedades y métodos de una clase padre. Veamos un ejemplo:

# Definimos la clase padre:
class ClasePadre:
# Decimos que se ejecute el código sin hacer nada.
  pass

# Y aquí la clase hija:
class ClaseHija(ClasePadre):
  pass

# Creamos el objeto
Objeto = ClaseHija()

Este es un ejemplo:

# Definimos la clase Familia
class Familia():

  # Con sus propiedades que se rellenarán cuando se inicialice el objeto.
  def __init__(self, miembros, apellidos):
    self.miembros = miembros
    self.apellidos = apellidos

    # Cuando se cree la clase, mostrará el apellido que ha recibido.
    print("Apellidos: %s" % (self.apellidos))

# Creamos la clase Hijo que hereda de Familia
class Hijo(Familia):

  # Se rellenarán propiedades para este objeto.
  def __init__(self, nombre, apellidos):

# Si queremos heredar propiedades y métodos, tendremos que hacer uso de la función super()
# super() lo explicaremos más adelante.
# Aquí llamamos la propiedad específica de Familia, Familia.apellidos y la inicializamos
    super().__init__(self,apellidos)

    # Definimos aquí los valores que tendrán estas propiedades
    self.nombre = nombre
    self.apellidos = apellidos

# Añadimos un método para el Hijo
  def mostrar_info(self):

    # Decimos que imprima self.nombre y self.apellidos.
    print("Soy %s y soy de la familia %s" % (self.nombre,self.apellidos))

# Creamos el objeto
Pugsley = Hijo("Pugsley","Adams")

# Llamamos al método mostrar_info()
Pugsley.mostrar_info()

Seguro que te preguntas sobre super().__init__(...), esta función como comentamos permite heredar propiedades y métodos de otra clase. Vendría a ser lo mismo que:

class A:
  def __init__(self, ejemplo):
    self.ejemplo = ejemplo

class B(A):
  def __init__(self, x, y, z):

    # Este procedimiento es más complicado y más tedioso de hacer.
    self.guardar_info = A(x)

obj = B(2,3,4)
print(obj.guardar_info.ejemplo)
Sobreescribiendo métodos en clases hijas

Se puede hacer evidentemente, si en la clase A tenemos un método llamado saludar(), y la clase B que hereda de la clase A, le podemos definir el contenido del mensaje que devolverá el método saludar().

class A:
  def saludar(self):
    print("Hola mundo")

class B(A):
  def saludar(self):
    print("Hello everybody")

obj = B
obj.saludar()

Y devolverá "Hello everybody".

Tipos de herencia

Bien, habiendo visto un ejemplo de herencia, también os cuento, que hay distintos ejemplos de herencia: * Simple * Múltiple * Multi nivel * Jerárquica * Híbrida

Simple

Es el tipo de herencia que hemos visto hasta ahora.

class A:
  pass
class B(A):
  pass

Múltiple

Es una clase que hereda desde otras clases, por lo que tendrá propiedades y métodos de ambas clases (A y B).

class A:
  pass
class B:
  pass
class C(A,B):
  pass

# Establecemos una comparación para ver si realmente son subclases o no.
# Devolverá True o False dependiendo de si es correcto o no.
issubclass(C,A) and issubclass(C,B)

Multinivel

Esto se refiere, a que tenemos una clase abuelo, de la cuál hereda una clase padre, del cuál hereda una clase hijo.

class A:
  pass
class B(A):
  pass
class C(B):
  pass

Como vemos, la clase C hereda de la clase B, la clase B de la clase A, y A es la clase principial de primer nivel. Por lo tanto, la clase C herederá propiedades y métodos de todas sus clases superiores a menos que se establezca qué propiedades o métodos se podrán heredar, esto forma parte del encapsulamiento que veremos más tarde.

Jerárquica

Tenemos múltiples clases que heredan de una sola clase, es decir.

class A:
  pass
class B(A):
  pass
class C(A):
  pass
class D(A):
  pass

Un ejemplo puede ser, clase Jefe/Jefa de una empresa que tiene el rol más alto de una organización y que por debajo de ellos hay otros roles acordes a la labor de la empresa que tienen menos privilegios, otras funciones...etc

Híbrido

Es la combinación de una o múltiples clases con una o múltiples clases por ejemplo: Imaginamos que tenemos 5 clases (A,B,C,D,E). * Clase A es una clase padre. * Clase B,C,D heredan de la clase A * Clase E, hereda de la clase B y D. * Clase E es la clase padre de B y D.

Aquí podemos identificar varios tipos de herencia: * A, B, C, D, C = Herencia híbrida * B, C, D que heredan de A = Herencia jerárquica * E que hereda de B y D = Herencia múltiple * C hereda de A = Herencia simple

Un ejemplo de sintaxis:

class A:
  pass
class B(A):
  pass
class C(A):
  pass
class D(A):
  pass
class E(B,D)

Si añadimos una variable en la clase A, creamos un objeto que referencie a E:

class A:
  hello_world = "Hola Mundo"
class B(A):
  pass
class C(A):
  pass
class D(A):
  pass
class E(B,D):
  pass
obj = E()
print(obj.hello_world)

´objhabrá impreso"Hola Mundo".`

Función super()

Se utiliza para llamar a métodos de una clase padre, hemos visto en un ejemplo anterior como llamábamos a super().__init__(self, nombre, apellidos) en el ejemplo de la Familia Adams. Aquí estábamos llamando al método inicializador de la clase Familia. Pero podemos llamar a otros métodos también. super().método().

class Vehiculo:
  def arrancar(self):
    print("Arrancamos el coche")
  def parar(self):
    print("Paramos el coche")

class Conductor(Vehiculo):
  def soplar(self):
    print("Soplando, soplando y soplando...")

  def control_policia(self):
    super().parar()
    print("Persona - Hola agente, buenos días")
    print("Policía - Hola, vamos hacerle una prueba de alcoholemia, por favor, sople en la boquilla")
    print("Persona - Vale")
    self.soplar()
    print("Policía - Genial, puede usted proseguir")
    super().arrancar()

Antonio = Conductor()
Antonio.control_policia()

Como vemos, no hace falta que llamemos a __init__ porque no estamos inicializando ningún valor en ninguna propiedad y como se ejecutan los métodos parar() y arrancar() que forman parte de la clase Vehiculo.

  • en Desarrollo
  • 4 minutos de lectura

Curso de Python - Imprimir valores y funciones

En esta entrega veremos: * Cómo imprimir valores de múltiples formas * Iteradores * Cómo trabajar con una función básica * Estamentos de return, yield * Asignando variables a la función * Asignando valores por defecto en dichas variables * Closures * Generadores * Función lambda

Sustitución de tipos de datos en sentencias print()

Cuando queremos incluir un valor que proviene de variables, listas, sets, tuplas... se pueden hacer de múltiples formas. Por ejemplo:

variable = "Susana"
print("Hola me llamo:", variable)
Hola me llamo Susana.

Podemos hacerlo de esta forma:

variable = "Susana"
print("Hola me llamo: %s" % variable)
Hola me llamo Susana.

Tenemos que tener en cuenta que de esta manera, hay que definir si el dato que vamos a sustituir es str = %s%, int = %i, float = %f. NOTA: Los valores de tipo complex = %c no tienen sustitución directa en esta forma, por lo que hay que utilizar otro método como en el anterior.

O de esta otra:

variable = Susana
print(f'Hola me llamo {variable}')

También tenemos esta otra:

variable = "Susana"
print("Hola me llamo {}".format(variable))

En fin, hay muchas formas de hacer sustituciones en los str y en otros tipos de datos que puedes consultar en la documentación oficial.

Iteradores

Un iterador es una especie de puntero que permite devolver valores que le especifiquemos.

lista= ["Hola","esto","es","un","ejemplo","de","iterador"]

# Inicializamos el iterador
mi_iterador = iter(lista)

# Se puede imprimir el valor de esta manera, que devuelve la palabra Hola
print(next(mi_iterador))

# Pasamos al siguiente iterador que contiene la palabra "esto", pero no la imprimimos.
next(mi_iterador)

# Imprimimos la palabra "es"
print(next(mi_iterador))

# Imprimir todos los elementos del iterador:
for item in mi_iterador:
  print(item)

Funciones

Las funciones son un conjunto de código organizado y que contienen una serie de instrucciones que pueden reutilizarse. Por ejemplo, dormir es una función que tenemos, hay múltiples variables como el lugar, la intensidad de la luz, si estamos cómodos... pero que al final el resultado es descansar. Lo mismo sucede con las funciones.

Declaración de ejemplo de una función:

def my_funcion():
  # Bloque de código

return

return permite devolver un valor de la función y darla por terminada más que utilizar un print()

def func(a):
  return a

valor=func(12)
print(valor)

yield

En contra posición de return, yield permite seguir aplicando el código que venga más adelante de la función creando una especie de co-rutina o gestión de resultados o ejecución por turnos, como si fuera un corredor de atletismo que le pasa el testigo a otro y su marca de tiempo es el valor de retorno. Hacemos uso de los iteradores para extraer los datos.

def func(a):
  print("Devolvemos el primer resultado: %i" % (a)) 
  yield a
  c = a - 2
  print("Devolvemos el segundo valor: %i" % (c))
  yield c

abc = func(20)

mi_iter = iter(abc)

for item in mi_iter:
    print(item)

Tipos de funciones en Python

En Python, tenemos 2 tipos de funciones, una que creamos nosotros y otras que vienen integradas. Las que nosotros creamos las definimos en nuestra aplicación, script... mientras que las integradas, vienen con la instalación de Python que ya fueron elaboradas y que puedes utilizar como: len(), max(), min(),type(),range()`...

Veamos un ejemplo:

>>> def hola_mundo():
>>>   print("Hola Mundo")
>>> hola_mundo()
Hola Mundo

Podemos pasar todo tipo de valores, por ejemplo, pasaremos una lista como valor y un número entero:

>>> lugares = [ "Toronto", "Tokio", "Nueva Zelanda" ]

>>> def mostrar_lugares(valores):
>>>   for lugar in valores:
>>>     print(lugar)
>>> mostrar_lugares(lugares)
Toronto
Tokio
Nueva Zelanda

Asignar una función a una variable

Podemos asignar una función a una variable y llamarla como función desde la propia variable:

def mensaje(msg):
    print(msg)

segundo=mensaje

# Imprime "Mundo"
segundo("Mundo")

Asignar valores por defecto a los argumentos

Si no le decimos o especificamos un valor cuando llamamos a la función, podemos hacer que tome parámetros por defecto.

def test(variable="Valor que queremos")
  print(variable)

test()

Esto devolverá "Valor que queremos", si especificamos un valor tal que así:

test("Hola mundo")

Devolverá Hola mundo.

Closures

Los closures es un objeto especial que permite obtener información de otras funciones hijas que forman parte de una función padre, permiten dar más seguridad al código ya que todo lo que tenga que ejecutarse se hará dentro de ese ámbito o scope.

Ejemplo de closure

def func(x):
    def func_a():
        print(x)
    return func_a()

Generadores

Son funciones que crean iteradores, estas funciones realmente son objetos en Python. Si hacemos un print sobre la función, veremos <generator object mensaje at 0x7f31a4957250>, es muy importante saberlo. No solo podemos trabajar con return, también con yield.

def mensaje(msg):
    def lector():
        print(msg, "%s" % ("leido por un lector."))
    def escritor():
        print(msg, "%s" % ("escrito por un escritor."))

    yield lector()
    yield escritor()

ejemplo = mensaje("Alguien escribió este mensaje y ha sido")

for item in ejemplo:
    if item is None:
        pass
    else:
        print(item)

Función Lambda

Esta función no tiene nombre también se le conoce como función anónima, sin embargo, no puede contener más de una expresión:

>>> x = lambda a : a + 10
>>> resultado = x(5)
>>> print(resultado)
15

Si lo pasamos a función esto sería así:

>>> def sumar(a,b):
>>>   return a + b
>>> sumar(5,10)
15

En la próxima entrega veremos cómo un usuario introduce datos y el control de excepciones.

  • en Desarrollo
  • 6 minutos de lectura

Curso de Python - Intérprete, comentarios, identificadores y palabras clave

En esta entrega aprenderás:

  • Algunos consejos básicos para trabajar con el intérprete de Python y crear archivos dónde trabajar con nuestro código
  • Comentar en Python que es lo primero que deberíamos aprender cuando estamos aprendiendo lenguajes de programación
  • Qué son los identificadores y algunas pautas que debemos seguir
  • Qué son las palabras clave y por qué no se usan

¿Cómo usar Python?

Sin duda un elemento imprescindible para poder trabajar con Python son los modos en los qué podemos trabajar con él. Podemos hacerlo de dos formas, mediante intérprete de comandos o elaborando un archivo de Python.

Intérprete de comandos

Si estas en Linux o BSD, puedes ver las múltiples (si hay), versiones instaladas en tu sistema si haces un simple: whereis python verás una salida como esta:

python: /usr/bin/python3.7-config 
/usr/bin/python2.7 
/usr/bin/python3.7m-x86_64-config 
/usr/bin/python /usr/bin/python3.7 
/usr/bin/python3.7m 
/usr/bin/python3.7m-config 
/usr/lib/python2.7 
/usr/lib/python3.7 
/usr/lib64/python2.7 
/usr/lib64/python3.7 
/usr/include/python2.7 
/usr/include/python3.7m

Como podemos ver, en mi sistema tengo instalados una versión de Python 3.7 como una 2.7. Es importante destacar que en el curso SIEMPRE trabajaremos con la rama 3.7 o superior porque la versión 2.7 quedó fuera de soporte desde el 31 de diciembre de 2019 y que prestaré más atención a SO Linux que *BSD.

¿Cómo sé que versión tengo por defecto en el sistema?

Si hacemos un ls /usr/bin |grep python veremos que un enlace simbólico está apuntado a una versión concreta.

lrwxrwxrwx.  1 root root              9 Jan 30 10:18 python -> ./python3
lrwxrwxrwx.  1 root root              9 Oct 21 15:13 python2 -> python2.7
-rwxr-xr-x.  1 root root          16072 Oct 21 15:13 python2.7

También se puede saber desde el gestor de paquetes que utilices a menudo en tu distribución de Linux o sistemas *BSD y/o ejecutando python -V que este te devolverá la versión:

$ python -V
Python 3.7.6

Acceder al intérprete de Python

Basta con que ejecutemos el comando python para empezar a trabajar.

$ python
Python 3.7.6 (default, Jan  8 2020, 19:59:22) 
[GCC 7.3.0] :: Anaconda, Inc. on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

Vemos una información de todo un poco, con qué compilador fue compilado Python, qué versión estamos utilizando...etc

Hay una sintaxis mínima que tenemos que entender del promp cuando usamos el intérprete: >>> se refiere a un código que puede ejecutarse sin identación por ejemplo cuando definimos una variable, una función...

>>> variable = 1

... aquí está mencionando que tenemos que indentar, es decir, añadir los espacios (4) correspondientes para respetar la sintaxis de Python.

>>> def func():
...    variable = 1

'SALIDA': Cuando solo salen estas comillas simples, está informando de un valor o imprimiendo la salida de una función, variable...etc

>>> import sys
>>> sys.version
'3.7.6 (default, Jan  8 2020, 19:59:22) \n[GCC 7.3.0]'
Usarlo como calculadora

Se pueden realizar operaciones aritméticas (ya las veremos más adelante) como suma, resta, división, multiplicación...

>>> 3 + 2
5
¿Cómo salir de la terminal?

Para salir podemos usar la función exit() o pulsar la combinación de teclas Ctrl + C

REPL tu intérprete en línea

REPL.it es una página que utilizaré mucho para dinamizar los ejemplos, se trata de un intérprete en línea que permite crear un entorno pequeño de Python y poder trabajar con él. En casi todos los ejemplos pondré un enlace para aquellas personas que quieran probar el código y no dispongan de intérprete.

Creando un archivo Python

Los archivos de Python tienen la extensión .py, y comienzan siempre declarando la ruta del intérprete, a esto se le conoce como SheBang. Por lo general, se suele utilizar la siguiente cabecera para evitar solapamientos con la versión 2.7. #!/usr/bin/env python3

Python 3 utiliza la codificación UTF-8 por defecto, por lo que si queremos trabajar con otro tipo de codificación tendremos que especificarla justamente debajo del SheBang.

#!/usr/bin/env python3
# -*- coding: latin-1 -*-

A partir de aquí añadimos nuestro código, que iremos aprendiendo a lo largo de las entregas de Python.

También es importante, que se le den permisos de escritura al archivo de Python para poderlo ejecutar desde terminal, si no obtendremos el error de permisos:

$ ./hola.py
bash: ./hola.py: Permission denied
$ chmod +x hola.py
$ ./hola.py
Hello world

Ya que sabemos esto, cuando en los comandos de ejemplo haga referencia a los diferentes tipos de prompt (>>>, ... o ' ') usamos directamente el intérprete y cuando no lo haga, estamos haciendo un archivo en Python.

¡Una vez que sabemos esto, adelante!

Comentarios

Algo muy importante sobre todo en nuestro código es comentar. Comentar nos permite recordar los cambios que hemos hecho en el código o tener al menos un punto de retorno porque cuando llevas muchas horas programando y programando, y revisando... dejas el código unos días, y te costará mucho entender y comprender todo el código de nuevo sin tener una ayuda de por qué decidimos hacer un cambio en la estructura, en el flujo del código...etc

¿Cómo se comenta en Python?

Si quieres comentar una línea, puedes usar:

# Comentamos con la almohadilla

Cuando queremos comentar múltiples líneas, utilizaremos esta sintaxis:

"""
Este es un comentario multilínea.
:D
"""

Ver ejemplo dinámico aquí.

Identificadores

Los identificadores son el nombre que se utilizan para identificar una variable, función, clases o un objeto. Las principales reglas que se deben respetar son las siguientes: * No se utilizan caracteres especiales o numéricos menos ( _ ) que se puede utilizar como un identificador * Las palabras clave no se utilizan * Python discrimina de mayúsculas y minúsculas por lo que no es lo mismo llamar a una función o variable var si está definida como Var. * Indentar es obligatorio, hay que respetar los espacios cuando se crean funciones, clases o métodos.

Variable

Las variables permiten almacenar un valor que le asignes como una cadena, un dato númerico, listas, tuplas... el tipo de valor lo veremos con más profundidad en entregas posteriores, pero hay que saber lo que hace este identificador y para que nos puede servir.

>>> variable = "Hello world"

Funciones

Permiten ejecutar un fragmento de código específico el cuál puede solicitar o no datos para la ejecución de dicho código.

>>> def nombre_funcion(argumentos):
...    # Bloque de código

Los argumentos se separan por comas.

Bucles

Permiten recorrer un conjunto de datos como un set|lista|tupla|collection...etc o ejecutarse desde un rango específico como por ejemplo, de 0 a 100 o de 1 a 5...etc

Bucle for

>>> for x in a:
...    # Bloque de código

Es el más común, pero no nos alarmemos que veremos más sobre los bucles en otras entregas posteriores.

Clases

Las clases son la plantilla de los objetos, Python es un lenguaje de programación orientado a objetos, por lo que es indispensable este identificador.

Propiedades

Son los atributos que tiene una clase, a fin de cuentas es como usar variables en otro contexto de programación.

Métodos

Son las funciones o acciones que tiene una clase.

Módulo

Son fragmentos de códigos externos o integrados en Python que realizan una serie de cosas, se puede conocer en otros lenguajes como librerías.

Pero no nos alarmamemos, todos estos identificadores los veremos más adelante de una forma más profunda.

Palabras clave

Python como otros lenguajes, tienen una serie de palabras que no se deben utilizar bajo ningún concepto para utilizarlos como identificadores. Podemos averiguar cuáles son desde su documentación oficial o importando el módulo keyword y su propiedad .kwlist

>>> import keyword
>>> print(keyword.kwlist)

Nos devolverá esta salida:

['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

NOTA: Ver ejemplo dinámico aquí. Todas estas palabras no se podrán utilizar como variables, nombres de lista, tuplas, diccionarios... porque su uso está reservado para otras finalidades.

También podemos averiguar si la palabra que estamos utilizando puede estar dentro de esta lista con su método .iskeyword().

>>> keyword.iskeyword('pass')

Esto devolverá como resultado True porque es una palabra reservada.

Y con esto nos veremos en la siguiente entrega, espero que os haya gustado, un saludo.

  • en Desarrollo
  • 5 minutos de lectura

Curso de Python - Introducción a la programación orientada a objetos

En este post aprenderás los principios básicos del POO o también llamada programación orientada a objetos que es uno de los paradigmas de la programación. En los post siguientes iré explicando más sobre lo que podemos hacer con ella además de mostrar algunos ejercicios.

Programación orientada a objetos o POO

Python es un lenguaje como ya mencionamos anteriormente orientado a objetos. Los objetos contienen una serie de métodos y propiedades que lo definen. Si pensamos en un humano, tenemos como propiedades el color de ojos, color de piel, altura... y los métodos serían las acciones como el baile, leer, saltar, correr...

Esta metodología de programación nos permite reusar el código las veces que queramos sin tener que estar escribiendo múltiples líneas con funciones específicas para determinadas partes de nuestro código si lo hicieramos en una programacioń estructurada o procedural.

Principios básicos de POO

En Python tenemos los siguientes principios: * Clase: Tipo de dato que contiene un esquema de métodos y propiedades que se usarán para construir un objeto. * Objeto: Una clase que se ha inicializado, es decir, existe y tiene nombres y apellidos propios en su ejecucioń. * Herencia: Propiedades o métodos que ha recibido una clase hija por parte de una clase padre, esto no quiere decir que vaya a heredar todos los métodos y propiedades, solo aquellos que se le permitan. * Encapsulación: La habilidad de enseñar aquello que solo se pueda mostrar y esconder lo que no nos interesa visibilizar. * Polimorfismo: La capacidad que tiene un objeto para cambiar su rol al mismo tiempo, puede actuar de un rol y en otro rol al mismo tiempo.

¿Qué es una clase?

Una clase es la plantilla que tendrá el objeto que queremos crear, contiene una serie de méotodos y propiedades que los utilizaremos una vez generemos el objeto. Por supuesto, una clase es un tipo de dato dentro de Python.

¿Cómo declaramos una clase?

Para generar una clase seguiremos esta sintaxis:

class NombreClase:
  # Bloque de código

¿Cómo podemos añadirle propiedades y métodos a una clase?

De la siguiente forma:

class Coche:
  propiedad = valor

  def método(self):
    # Bloque de código

Un ejemplo podría ser:

class Coche:
  marca = "Toyota"
  modelo = "Corolla"

  def publicidad(self):
    print("De 0 a 100 en 10 segundos")

Tenemos la clase Coche, con unas propiedades definidas que son la marca y el modelo, además, tenemos un método llamado publicidad que muestra un mensaje. En el siguiente apartado, veremos como trabajar con esta clase pero desde la vista de un objeto.

¿Qué es un objeto?

Un objeto es la materialización de una clase, es decir, cuando lo generamos a partir de unas instrucciones ya empieza a existir en nuestro programa que estemos desarrollando. Por ejemplo, tenemos la clase Casa, evidentemente, las casas que declaremos tiene propiedades y métodos diferentes, por ejemplo, tiene una dirección, un número, una elevación, una función, un espacio diferente. Si creamos 5 casas, hemos creado 5 objetos partiendo de una sola clase que es la clase Casa.

En resumen: * Es la unidad básica de POO * Representa una instancia particular partiendo de una clase * Puede haber más instancias partiendo de una misma clase * Cada objeto puede contener y mantener su información

¿Cómo declaramos un objeto?

La sintaxis es:

NombreObjeto = NombreClase()

En este ejemplo creamos 3 objetos diferentes partiendo de la clase anterior.

NombreObjeto = NombreClase()
NombreObjeto2 = NombreClase()
NombreObjeto3 = NombreClase()

Para acceder a sus propiedades:

NombreObjeto.propiedad1

Para acceder a sus métodos:

NombreObjeto.método1()

Utilizando el ejemplo que hemos creado antes:

class Coche:
  marca = "Toyota"
  modelo = "Corolla"
  publicidad = "De 0 a 100 en 10 segundos"

  def eslogan(self):
    print("Este es un método",self.publicidad)

Sara = Coche()
Ionela = Coche()

Tenemos a dos personas que utilizan el mismo coche Ionela y Sara y lo vemos:

print(Ionela.marca,Ionela.modelo)
Toyota Corolla
Ionela.eslogan()
De 0 a 100 en 10 segundos

print(Sara.marca,Sara.modelo)
Toyota Corolla
Sara.eslogan()
De 0 a 100 en 10 segundos

¿Qué pasa si Sara quiere cambiar de coche?

Sara.marca = "Citröen"
Sara.modelo = "Xsara"
Sara.publicidad = "El confort no es discutible."
print(Sara.marca,Sara.modelo)
Citröen Xsara
Sara.eslogan()
El confort no es discutible.

¿Pero Ionela ha cambiado de coche?

print(Ionela.marca,Ionela.modelo)
Toyota Corolla
Ionela.eslogan()
De 0 a 100 en 10 segundos

¡Ya lo tenemos! Podemos instanciar objetos diferentes partiendo de una misma clase y cambiar sus propiedades sin afectar al resto de objetos. ¿A qué es sencillo? Pero, ¿Qué pasa si queremos cualquier persona pueda tener un coche diferente desde el principio?

Pues a pesar de que se puede hacer creando un método que le asigne el valor a las propiedades, lo más correcto es utilizando el método __init__. Este método constructor (que permite inicializar un objeto) asigna valores a las propiedades del objeto cuando se construye, por ejemplo.

class NombreClase:
  def __init__(self, valor_propiedad1, valor_propiedad2):
    self.propiedad1 = valor_propiedad1
    self.propiedad2 = valor_propiedad2

  def metodo1(self):
    # Bloque de código

Para crear el objeto:

Variable=NombreClase("Valor de ejemplo n1","Valor de ejemplo n2")

Si parece dificultoso de entender, no pasa nada, este es otro ejemplo con comentarios (¡Será por ejemplos!):

# Definimos la clase Coche
class Coche:

  # Definimos el constructor que sustituirá los 
  # valores de las propiedades cuando las definamos al inicializar el objeto.

  def __init__(self,marca,modelo, velocidad):
    self.marca = marca
    self.modelo = modelo
    self.velocidad = velocidad

  # Cuando se llama a este método la velocidad se incrementa +1.
  def acelerar(self):
    self.velocidad += 1
    print(self.velocidad)

  # Cuando se llama a este método la velocidad disminuye en -1.  
  def frenar(self):
   self.velocidad -= 1
   print(self.velocidad)

# Creamos los objetos:

Chami = Coche("Nissan", "Almera", 0)
Jose = Coche("Toyota","Corolla AE92 GTi Twin Cam", 0)

# Imprimimos los valores que tienen las propiedades de cada objeto:

print("El coche de Chami es un:",Chami.marca,Chami.modelo,"y ahora va a",Chami.velocidad,"km/h.")
print("El coche de Jose es un:",Jose.marca,Jose.modelo,"y ahora va a",Jose.velocidad,"km/h.")

# Aumentamos la velocidad a uno de los objetos:
Chami.acelerar()

# Si queremos aumentar más veces la velocidad, podemos usar un bucle
for x in range(0, 100):
  Chami.acelerar()

# Imprimimos la velocidad actual
print("Chami va a una velocidad de %i" % Chami.velocidad)

Este ejemplo si lo ejecutamos dará como resultado:

El coche de Chami es un: Nissan Almaera y ahora va a 0 km/h.
El coche de Jose es un: Toyota Corolla AE92 GTi Twin Cam y ahora va a 0 km/h.