Saltar a contenido

Desarrollo

  • 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.
  • en Desarrollo
  • 4 minutos de lectura

Curso de Python - Introducir datos, control de excepciones, trabajar con archivos

Bienvenidos al nuevo post del curso de Python, al terminar este post ya sabrás como introducir datos por el teclado, cómo gestionar el control de excepciones y mostrar lo que te interesa según el error y sobre todo, trabajar con archivos de texto.

Obtener datos introducidos por el usuario

Tenemos una función que es input() y podemos solicitar al usuario que introduzca un dato y que este se almacene en una variable, esto nos puede ayudar a dinamizar los programas interactuando con los usuarios:

input('Aquí va un mensaje')

NOTA: Los datos introducidos se almacenan como un str, por lo que si quieres almacenar datos tipo float, int tendrás que usar la función de conversión que hemos hablado en el apartado de Tipos de datos en Python. Vamos hacer este ejemplo:

nombre = input("¿Cómo te llamas? ")
edad = int(input("¿Qué edad tienes? "))
print("Me llamo %s y tengo %i años." % (nombre,edad))

Imprimirá un resultado como:

¿Cómo te llamas? Alvaro
¿Qué edad tienes? 26
Me llamo Álvaro y tengo 26 años.

Control de excepciones

¿Qué ocurre si queremos ejecutar un código y depende de una serie de datos que no se han inicializado? No pasa nada, tenemos un mecanismo que controla las excepciones.

try-except

try:
  # Bloque de código que se probará antes de ejecutar
except:
  # Bloque de código que se ejecutará si ocurre algún error.

Por ejemplo:

try:
    print(a)
except:
    print("Hubo un problema.")

Esto nos imprimirá Hubo un problema. pero no nos dice en ningún momento dónde está el error. Evidentemente, el error es que la variable a no contiene ningún tipo de valor. Pero, ¿Qué ocurre si quiero personalizar estos errores y mostrar información según convenga?

No pasa nada, podemos añadir excepciones por error, por ejemplo, si la variable a no existía, podemos crear una excepción que permita decir que no existe porque no está creada de la siguiente forma.

  1. Primero identificamos como se llama el error en Python:
print(A)
Traceback (most recent call last):

  File "/tmp/untitled0.py", line 9, in <module>
    print(a)

NameError: name 'a' is not defined

El nombre del error que tenemos que utilizar es NameError.

  1. Definimos el try-except de la siguiente manera:
try:
  print(a)
except NameError:
  print("La variable no se ha asignao, por favor, revisa el programa.")
except:
  print("Hubo un problema, contacte con el desarrollador de la aplicación.")

¿Se pueden definir múltiples errores y que impiman un mensaje? Sí que se puede, esto además nos permite ahorrar mucho código.

try:
  pass
except(NameError, TypeError, ValueError):
  pass
except:
  pass

También podemos usar un alias e imprimir solo el mensaje de error:

try:
  print(a)
except(NameError, TypeError, ValueError) as EstoEsUnError:
  print(EstoEsUnError)
except:
  pass

¿Para qué nos sirve esto? Para tener un mayor control en la validación e impresión de nuestro código. EstoEsUnError imprimirá: NameError: name 'a' is not defined, con este str podemos iniciar una validación on if-elif-else.

with

with es un método que permite realizar acciones que posteriormente necesitan limpiarse para que no queden restos en memoria, un ejemplo muy común y extendido es cuando se trabaja con archivos.

with open('nombreArchivo.ext', modo') as fichero:
  # Bloque de código

Cuando abrimos el archivo de esta forma, aunque hayan problemas con el archivo, este termina cerrándose y dejando de existir en la memoria. Sin embargo, si trabajamos con el archivo de la siguiente forma, el archivo quedará en la memoria de forma casi indefinida en el tiempo generando datos basura:

fichero = open('nombreArchivo.ext','modo')

Además, de que hay que cerrarlo debidamente:

fichero.close()

En el siguiente punto trabajaremos más con los archivos, no nos alarmemos.

Puedes consultar más información sobre este apartado en este hilo de la documentación.

Trabajando con archivos en Python

¿Qué podemos hacer en Python con los archivos? ¿Podemos trabajar con ellos? La cuestión es que sí, podemos abrir, leer, escribir o crear y eliminar archivos, las operaciones básicas que nos deja hacer un SO si estuvieramos en una shell como bash o zsh.

Abriendo un archivo

La sintaxis que se utiliza es:

fichero = open("ruta del archivo", modo)

La sintaxis correcta,que debe usarse y que utilizaremos en estos ejemplos es:

with open("ruta del archivo", modo) as nombreFichero:
  # Bloque de código
Modo Descripción
r Lectura, es el valor por defecto, abre el archivo para que se pueda leer y da un error si el archivo no existe.
a Abre un archivo para agregarle información al final, si no existe el archivo lo crea.
w Sobreescribe cualquier contendio que haya en el archivo que esté abierto y/o crea el archivo si no existe.
x Crea el archivo, si devuelve error quiere decir que ya existe.

Leer archivo

Creamos este archivo:

$ cd /home/$USER/
$ cat << EOF >> hola.txt
> Hola Mundo
> EOF

Si hacemos un cat hola.txt nos mostrará Hola Mundo. Bien, abrimos el archivo con Python

>>> with open("hola.txt","r") as fichero:
>>>   fichero.read()
Hola Mundo

Este método también permite decirle que nos imprima los n caracteres del principio del texto con .read(4).

Devuelve una línea

Si tenemos un archivo con más líneas, podemos imprimirlas con .readline() en vez de .read(). Sin embargo, si queremos imprimir mas líneas, tenemos que llamar varias veces al método.

>>> fichero.readline()
>>> fichero.readline()

Leer el archivo completo

Con ayuda de un bucle for lo hacemos:

>>> with open("ejemplo.txt", "r") as fichero:
>>> for linea in fichero:
>>>   print(linea)

Creando un archivo nuevo

Si el archivo existe, dará error.

>>> with open("ejemplo.txt", "x") as fichero:

Cuando terminemos de escribir en un archivo, lo cerramos para que no quede en memoria.

fichero.close()

Añadir información al archivo

En esta línea añadimos el siguiente texto.

>>> with open("hola.txt","a") as fichero:
>>> fichero.write("Esta es una línea de ejemplo")

Cuando terminemos de escribir en un archivo, lo cerramos para que no quede en memoria.

fichero.close()

Sobreescribir en el archivo

Sobreescribimos el archivo si lo abrimos con el modo w:

>>> with open("hola.txt","w") as fichero:
>>> fichero.write("Te he sobreescrito el contenido con esta línea")

Cuando terminemos de escribir en un archivo, lo cerramos para que no quede en memoria.

fichero.close()

Eliminar un archivo

Hay que importar un módulo llamado os:

import os

os.remove("hola.txt")
  • en Desarrollo
  • 5 minutos de lectura

Curso de Python - Introducción y preparación del entorno

Historia

Python es un lenguaje de programación interpretado, de alto nivel y de interés general. Este lenguaje tiene una filosofía de programación que se centra en la legibilidad del código, para ello implementa una serie de declaraciones y estándares que ha de respetarse para que el código funcione como es la indentación. Python es un lenguaje orientado a objetos que facilitan a los desarrolladores escribir un código limpio, eficaz, lógico y pequeño que sirve tanto para pequeños, como medianos y grandes proyectos.

La primera versión de Python se publicó en el año 1991 por Guido van Rossum un programador holandés graduado en matemáticas y ciencias computacionales en la universidad de Amsterdam en 1982. Posteriormente se publicó la versión 2.0 el día 16 de octubre del año 2000 y la versión 3.0 que se liberó el 3 de diciembre de 2008. Actualmente las versiones 1.0 y 2.0 ya no están soportadas, esta última dejó de tener soporte el día 31 de diciembre de 2019.

Notas importantes

Antes de seguir con este artículo es muy importante que sepamos que la versión con la que trabajaremos en las siguientes entragas es Python 3. Python 2.7 no tiene más soporte desde el 31 de diciembre del 2019.

A parte de la versión, conviene saber que tenemos que leer mucho la documentación oficial (inglés) si no queremos perder horas y horas con las clásicas pruebas de Error/Acierto (pruebo cosas al azar y lo que salga salió).

También tenemos muchos recursos en línea como Real Python (inglés) que contienen muchos recursos bastante bien explicados; Full Stack Python (inglés) tiene tambień muchos recursos, ayudas...

Instalación

Python por norma general está instalado por defecto en el 99% de distribuciones de Linux por lo que no te hará falta tener que instalar nada. Sin embargo, hay distribuciones que a pesar de que Python 2. se encuentre obsoleto, la mayor parte de librerías y programas que contienen en su sistema operativo hacen uso de la versión 2.7. que fue la última en mantenerse. Por lo que, quizás necesites realizar unos pasos adicionales para tener Python 3.* instalado en tu Linux.

Algunas distribuciones pueden ser: * CentOS 6/7, hay que hacer uso de Software Collections puedes hacer uso de esta guía que elaboré. * Debian Stable * RHEL 6/7 * Gentoo

En FreeBSD y OpenBSD hay que instalarlo con su respectiva paquería, puedes utilizar estas guía oficial de Python para hacerlo.

En Windows tenemos dos formas de hacerlo, una es utilizando el subsistema de Linux para Windows haciendo uso de un sistema Linux ejecutándose en un Windows, o bien, la forma oficial que es utilizar el instalador oficial elaborado por la comunidad de Python. Para descarganos el instalador hay que dirigirse a la página de descargas pulsando aquí.

Una vez descargado, ejecutamos el instalador y seguimos los pasos como tenemos en las imágenes:

Desmarcamos la opción de instalar para todos y marcamos la opción de añadir a la variable PATH, después "Install Now":

Vemos como se está instalando:

En este paso, deshabilitamos el path lenght limit:

Y desde PowerShell podemos abrir el ejecutable directamente, veremos la versión que estamos utilizando.

IDEs

Hay una gran selección de IDEs bastante buenos que podemos utilizar para aprender, hay tanto de pago, gratuitos, libres y no libres... hay un gran abanico para decidir.

IDLE

Un IDE que viene integrado con Python (incluyendo en la instalación de Windows en la que hemos hablado más arriba). Permite ejecutar código directamente, depurarlo y tiene un pequeño editor dónde realizar nuestras modificaciones.

Spyder

Es un IDE gratuito y libre que contiene multitud de funciones desde depuración, ejecución y redacción de un archivo en Python todo en una misma ventana. Pues ver más info aquí.

Jupyter Notebook

Es un servidor web que mediante estilos, javascripts y html5 genera un IDE web con el que poder interactuar, al igual que todos permite depurar, crear archivos, navegar por los directorios del sistema operativo...etc Más info

Navegando por los directorios del SO desde su interfaz web

Ejecutando comandos de Python en un archivo nuevo

Abriendo una sesión de SO desde Web

Jupyter labs

Basado en Jupyter Notebook y Arquitecture contiene más características, como especificar qué versión de Python lanzar, ejecutar una consola directamente de Python o de SO... Más info.

Anaconda

Anaconda es un software que contiene todo lo necesario para desplegar un entorno de desarrollo de Python tanto en Linux como en Windows. No solo contiene el intérprete, si no que también tienen varios editores que puedes seleccionar desde su panel "Anaconda Navitator". Más info.

PyCharm

PyCharm es un software elaborado por la empresa JetBrains, es bastante conocido porque tiene un potente interfaz de desarrollo que permite hacer carga de espacios de nombres, módulos, referencias... y es muy potente. Aunque es de pago, si eres estudiante y tienes la ISIC puedes obtener una licencia anual gratuita para todos los productos de la empresa como DataGrid, PhpStorm, CLion... y poder hacer tus desarrollos (siempre personales y no comerciales) con él. No obstante, si no eres estudiante, y no quieres comprar la licencia, puedes hacer uso de la versión comunitaria.Más info.

Editores

Si no te gusta utilizar un IDE, siempre puedes hacer uso de editores como vim, Sublime Text, VSCode con sus correspondientes plugins. Algunas de estas personalizaciones las hablaremos en otros posts.

Siguiente entrega

En el próxmo artículo, hablaremos de los principales conceptos básicos como son los identificadores, palabras reservadas, variables, funciones, tipos de datos, módulos... cada apartado que veamos tendrá un ejemplo de uso por lo que será más fácil aprender la lógica de los mismos.

¡Os espero en la siguiente entrega, y espero que os haya gustado este post!