Tipos de datos en Python

Los tipos en Python son una representación de los datos, ya que no requiere que las variables declaren su tipo, porque todos los tipos se convierten de forma automática

Podemos utilizar la función type para conocer el tipo de una variable

Tipo booleano

El tipo booleano simplemente distingue entre dos estados, un estado de éxito o de activado, valor verdadero, True, y un estado de fracaso o de desactivado, valor falso, False

Ambos estados no son susceptibles a mayúsculas y minúsculas

foo = True #asigna el valor True a la variable foo

Normalmente, el resultado de operadores que devuelven un valor de tipo booleano son pasados a las estructura de control

mostrar_separadores = True #declaramos la variable con un booleano

#esto no es necesario...
if mostrar_separadores == True:
    print("<hr>\n")

#...porque podemos ahorrar código escribiendo:
if mostrar_separadores:
    print("<hr>\n")

print( type(mostrar_separadores) ) #devolverá <class 'bool'>

Tipos numéricos

En Python existen 4 tipos diferentes de variables numéricas:

• int

  número entero con precisión fija

• long

  número entero en caso de sobrepasar el tamaño de un int

• float

  número en coma flotante de doble precisión

• complex

  número complejo (parte real + j parte imaginaria)

entero = 1
print( type(entero) ) #devolverá <class 'int'> 

real = 1.23
print( type(real) ) #devolverá <class 'float'> 

complejo = 1 + 2j
print( type(complejo) ) #devolverá <class 'complex'>

Es el intérprete el que decide el tipo de variable según lo que definimos

Sin embargo, podemos querer forzarlo nosotros mediante un cast

entero = int(1)
print( type(entero) ) #devolverá <class 'int'> 

real = float(1.23)
print( type(real) ) #devolverá <class 'float'> 

complejo = complex(1 + 2j)
print( type(complejo) ) #devolverá <class 'complex'>

Tipo string

Un string es una cadena de caracteres delimitadas por comillas

Un literal de tipo string se puede especificar de dos formas diferentes:

• entrecomillado simple

  se especifican entre los carácteres ‘ de apertura y ‘ de cierre

  Para especificar una comilla simple literal, se ha de escapar con una barra invertida (\). Para especificar una barra invertida literal, se duplica (\\)

  Todas las demás instancias de barras invertidas serán tratadas como una barra invertida literal: esto significa que otras secuencias de escape que podrían utilizarse, tales como \r o \n, serán mostradas literalmente tal y como se especifican, en lugar de tener cualquier otro significado especial

  print('Esto es una cadena sencilla')
  
  #Resultado: Arnold una vez dijo: "Volveré"
  print('Arnold una vez dijo: "Volveré"')
  
  #Resultado: Ha borrado C:\*.*?
  print('Ha borrado C:\\*.*?')
  
  #Resultado: Ha borrado C\:*.*?
  print('Ha borrado C:\*.*?')
  
  #Resultado:
  #Esto se expandirá:
  #una nueva línea
  print('Esto se expandirá:\nuna nueva línea')

• entrecomillado doble

  se especifican entre los carácteres " de apertura y " de cierre

  Python interpretará las siguientes secuencias de escape como caracteres especiales:

  Código	Descripción
  \n	avance de línea (LF o 0x0A (10) en ASCII)
  \r	retorno de carro (CR o 0x0D (13) en ASCII)
  \t	tabulador horizontal (HT o 0x09 (9) en ASCII)
  \\	barra invertida
  \"	comillas dobles

  print("Esto es una cadena sencilla")
  
  #Resultado: Arnold una vez dijo: "Volveré"
  print("Arnold una vez dijo: \"Volveré\"")
  
  #Resultado: Ha borrado C:\*.*?
  print("Ha borrado C:\\*.*?")
  
  #Resultado: Ha borrado C\:*.*?
  print("Ha borrado C:\*.*?")
  
  #Resultado:
  #Esto se expandirá:
  #una nueva línea
  print("Esto se expandirá:\nuna nueva línea")

Métodos

Vamos a ver algunos de los métodos para cadenas de uso más cotidiano

Métodos de formato

Afectan al formato del texto contenido en la cadena

• capitalize()

  Realiza una copia de la cadena con la primera letra en mayúsculas

• lower()

  Devuelve una copia de la cadena en minúsculas

• upper()

  Devuelve una copia de la cadena en mayúsculas

• swapcase()

  Devuelve una copia de la cadena en la que las mayúsculas son minúsculas y viceversa

• title()

  Devuelve una copia de la cadena en la que la primera letra de cada palabra es mayúscula y las demás minúsculas

• center(longitud, ‘caracter de relleno’)

  Devuelve una copia de la cadena de entrada centrada en la longitud indicada y entre el caracter de relleno que se indique

• ljust(longitud, ‘caracter de relleno’): Devuelve una copia de la cadena alineada a la izquierda

• rjust(longitud, ‘caracter de relleno’)

  Devuelve una copia de la cadena alineada a la izda/derecha

• zfill(longitud)

  Devuelve una copia de la cadena rellenada con ceros a la izda hasta alcanzar la longitud indicada

numero_factura = 892
cadena = 'tEngO UNa caSa aZUL'

print( cadena.capitalize() ) #devuelve 'Tengo una casa azul'
print( cadena.lower() ) #devuelve 'tengo una casa azul'
print( cadena.upper() ) #devuelve 'TENGO UNA CASA AZUL'
print( cadena.swapcase() ) #devuelve 'TeNGo unA CAsA Azul'
print( cadena.title() ) #devuelve 'Tengo Una Casa Azul'
print( cadena.center(40, '=') ) #devuelve '==========tEngO UNa caSa aZUL==========='
print( cadena.capitalize().center(40, '=') ) #devuelve '==========Tengo una casa azul==========='
print( cadena.rjust(40, '=') ) #devuelve '=====================tEngO UNa caSa aZUL'
print( str(numero_factura).zfill(12) ) #devuelve '000000000892'

Métodos de búsqueda

Nos permiten buscar dentro de una determinada cadena para comprobar si una subcadena está contenida en la cadena o cuántas veces aparece una subcadena

• count(‘subcadena’)

  Devuelve un entero representando la cantidad de apariciones de la subcadena dentro de la cadena

• find(‘subcadena’)

  Devuelve un entero representando la posición en la que empieza la subcadena dentro de la cadena

cadena = 'las elecciONES Generales A LA presidenCIA del gobierno son EL 28 de abril'

print( cadena.count('la') ) #devuelve 1
print( cadena.lower().count('la') ) #devuelve 2
print( cadena.lower().find('elecciones') ) #devuelve 4
print( cadena.lower()[4:] ) #devuelve 'elecciones generales a la presidencia del gobierno son el 28 de abril'
print( cadena.lower()[cadena.lower().find('elecciones'):] ) #devuelve 'elecciones generales a la presidencia del gobierno son el 28 de abril'

Métodos de validación

Nos devuelven siempre un booleano, es decir, True o False

Sirven para comprobar si una cadena cumple una determinada condición

• startswith(‘subcadena’)

  Nos dice si una cadena comienza por una cadena determinada

• endswith(‘subcadena’)

  Nos dice si una cadena termina por una cadena determinada

• isalnum()

  Nos dice si una subcadena es alfanumérica

• isalpha()

  Nos dice si una cadena es alfabética

• isdigit()

  Nos dice si una cadena es numértica

• islower()

  Nos dice si una cadena contiene sólo minúsculas

• isupper()

  Nos dice si una cadena contiene sólo mayúsculas

• isspace()

  Nos dice si una cadena contiene sólo espacios en blanco

• istitle()

  Nos dice si una cadena tiene formato de título

cadena = 'las elecciONES Generales A LA presidenCIA del gobierno son EL 28 de abril'

print( cadena.startswith('las') ) #devuelve True
print( cadena.endswith('las') ) #devuelve False
print( cadena.isalnum() ) #devuelve False
print( cadena.isalpha() ) #devuelve False
print( cadena.isdigit() ) #devuelve False
print( cadena.islower() ) #devuelve False
print( cadena.isupper() ) #devuelve False
print( cadena.isspace() ) #devuelve False
print( cadena.istitle() ) #devuelve False

Métodos de sustitución

Nos permiten sustituir texto para unificar el formato de diferentes cadenas que nos han llegado por vías diferentes

• format(argumentos)

  Podemos tener una cadena que esté preparada para recibir una cierta cantidad de argumentos

  Al llamar a esta función e introducir los argumentos necesarios nos devuelve una copia de la cadena ya formateada

• replace(‘subcadena buscada’, ‘subcadena que poner’)

  Busca dentro de la cadena una subcadena y la sustituye por la cadena indicada

• strip()

  Elimina el carácter que indiquemos de la derecha y de la izquierda de la cadena

  Por defecto busca el carácter espacio

• lstrip()

  Elimina los caracteres a la izquierda de una cadena

  Si introducimos como argumento una subcadena, busca esa subcadena y las combinaciones de los caracteres de la subcadena desde la izquierda hasta que no encuentre ninguno más

• rstrip()

  Elimina los caracteres a la a derecha de una cadena

  Si introducimos como argumento una subcadena, busca esa subcadena y las combinaciones de los caracteres de la subcadena desde la derecha hasta que no encuentre ninguno más

usuario = " pedro"
dominio = "proveedor.net "
mail = usuario + "@" + dominio

print( mail.replace("pedro", "juan") ) #muestra ' juan@proveedor.net '
print( mail.strip() ) #muestra 'pedro@proveedor.net'
print( mail.lstrip(usuario) ) #muestra '@proveedor.net '
print( mail.rstrip(dominio) ) #muestra ' pedro@

Métodos de unión y división

Nos permiten sustituir texto para unificar diferentes cadenas que nos han llegado por vías diferentes o para separar una cadena en varias

• join(iterable)

  Recibe como argumento un iterable y devuelve como resultado los elementos del iterable unidos por el carácter de la cadena sobre la que se aplica

• partition(‘separador’)

  Devuelve una tupla de 3 elementos

  El primer elemento es lo que hay a la izquierda del ‘separador’, el segundo elemento es el separador y el tercer elemento es lo que hay a la derecha del separador

• split(‘separador’)

  Devuelve una lista con todos los elementos encontrados al dividir la cadena por el separador

• splitlines()

  Devuelve una lista donde cada elemento es una fracción de la cadena dividida en líneas

caracter = ", "
listas =  ['pan', 'lechuga', 'tomates', 'peras', 'manzanas']
usuario = "pedro"
dominio = "proveedor.net"
separador = "@"
mail = usuario + separador + dominio
compra = "pan, lechuga, tomates, peras, manzanas"

print( caracter.join(listas) ) #devuelve "pan, lechuga, tomates, peras, manzanas"
print( mail.partition(separador) ) #devuelve "('pedro', '@', 'proveedor.net')"
print( mail.partition(separador)[0] ) #devuelve "pedro"
print( mail.partition(separador)[2] ) #devuelve "proveedor.net"
print( compra.split(caracter) ) #devuelve "['pan', 'lechuga', 'tomates', 'peras', 'manzanas']"
print( compra.splitlines() ) #devuelve "['pan, lechuga, tomates, peras, manzanas']"

Listas

Se definen poniendo el contenido de la lista entre corchetes, separando cada uno de los elementos mediante una coma

Cada posición de la lista puede contener elementos de distinto tipo

Las listas son mutables, es decir, sus elementos pueden ser modificados

En Python los elementos de una lista se numeran desde 0 hasta longitud – 1

Para acceder al elemento de una lista se pone el nombre de la lista y a continuación el índice al que queremos acceder (si ponemos el índice con signo negativo empezará por el final de la lista)

Para acceder a un rango dentro de una lista tenemos diferentes opciones:

• Tomar elementos desde el inicio: lista[:a]
• Tomar elementos desde la posición a (incluida) hasta el final: lista[a:]
• Tomar elementos desde a hasta b (sin incluir b): lista[a:b]

El inicio del rango siempre incluye el elemento en esa posición, pero no el final del rango

listas = [1, 2, 3, 4, 5, 6]

print( len(listas) ) #devuelve 6, que es la longitud de la lista
print( listas[0] ) #devuelve 1
print( listas[-1] ) #devuelve 6
print( listas[:2] ) #devuelve [1, 2]
print( listas[2:] ) #devuelve [3, 4, 5, 6]
print( listas[1:4] ) #devuelve [2, 3, 4]

Métodos

Vamos a ver algunos de los métodos para listas de uso más cotidiano

• append()

  añade un elemento al final de la lista

• insert()

  se usa para insertar un elemento en el índice asignado

• pop()

  elimina y devuelve el valor en la posición del índice asignado

• reverse()

  reordena la lista de forma reversa

• sort()

  reordena la lista de forma ascendente

mi_lista = [1, 3, 5, 4, 2]

print(mi_lista) #devuelve [1, 3, 5, 4, 2]
mi_lista.append(6)
print(mi_lista) #devuelve [1, 3, 5, 4, 2, 6]
mi_lista.insert(0, 8)
print(mi_lista) #devuelve [8, 1, 3, 5, 4, 2, 6]
valor = mi_lista.pop(0)
print(mi_lista, valor) #devuelve [1, 3, 5, 4, 2, 6] 8
mi_lista.reverse()
print(mi_lista) #devuelve [6, 2, 4, 5, 3, 1]
mi_lista.sort()
print(mi_lista) #devuelve [1, 2, 3, 4, 5, 6]

Podemos encontrar todos los métodos en su documentación

Tuplas

Las tuplas son similares a las listas, se definen con paréntesis en vez de corchetes

Tienen la peculiaridad de ser inmutables

mi_tupla = (1, 2, 3, 4, 5, 6)

print( len(mi_tupla) ) #devuelve 6, que es la longitud de la tupla
print( mi_tupla[0] ) #devuelve 1
print( mi_tupla[-1] ) #devuelve 6
print( mi_tupla[:2] ) #devuelve [1, 2]
print( mi_tupla[2:] ) #devuelve [3, 4, 5, 6]
print( mi_tupla[1:4] ) #devuelve [2, 3, 4]

Como puede verse, se accede a los elementos de igual forma que con las listas

Diccionarios

Los diccionarios definen una relación de uno a uno entre clave valor entre {} y son mutables

Se definen colocando una lista separada por comas de pares clave:valor

Una vez definido, podemos acceder al valor asociado a una clave buscando por clave

Además, podemos buscar si una determinada clave existe o no en nuestro diccionario

Los diccionarios son un tipo de colección en Python que, a diferencia de las listas, están indexadas por palabras y no por números

Los valores pueden ser de cualquier tipo

Podemos pensar en un diccionario como un conjunto no ordenado de pares clave:valor con el requisito de que las claves tienen que ser únicas

diccionario = {
    'int':'Número entero',
    'float':'Número real',
    'complex':'Número complejo'    
}

print( type(diccionario) ) #devuelve <class 'dict'>
print( diccionario['int'] ) #devuelve Número entero
print( 'int' in diccionario) #comprobamos si la clave 'int' existe en el diccionario, devuelve True
print( 'long' in diccionario) #comprobamos si la clave 'long' existe en el diccionario, devuelve False

Métodos

Vamos a ver algunos de los métodos para diccionarios de uso más cotidiano

• keys()

  nos devuelve un iterable que contiene las claves del diccionario

• values()

  nos devuelve un iterable que contiene los valores del diccionario

• items()

  nos devuelve un iterable con los pares clave:valor del diccionario

diccionario = {
    'int':'Número entero',
    'float':'Número real',
    'complex':'Número complejo'    
}

print( diccionario.keys() ) #devuelve dict_keys(['int', 'float', 'complex'])
print( diccionario.values() ) #devuelve dict_values(['Número entero', 'Número real', 'Número complejo'])
print( diccionario.items() ) #devuelve dict_items([('int', 'Número entero'), ('float', 'Número real'), ('complex', 'Número complejo')])

Objetos

Los objetos se componen de un conjunto de valores, propiedades y un conjunto de métodos aplicados a esos valores

Son estos métodos los que nos permiten modificar el estado de dicho objeto, es decir, el valor de sus propiedades

En Python los objetos tiene las siguientes particularidades:

• Todo es un objeto, incluyendo los tipos y clases
• Permite herencia múltiple
• No existen métodos ni atributos privados
• Los atributos pueden ser modificados directamente

• Permite monkey patching

  Las clases se crean en tiempo de ejecución pero pueden modificarse tras ser creadas

• Permite duck typing

  El estilo de tipificación dinámica de datos en que el conjunto actual de métodos y propiedades determina la validez semántica, en vez de que lo hagan la herencia de una clase

• Permite la sobrecarga de operadores
• Permite la creación de nuevos tipos de datos

Vamos a crear un objeto Universitario de ejemplo en el que tendremos las propiedades: Nombre, Apellido, Edad y Dni

La instancia del objeto la crearemos mediante la asignación a una variable de la siguiente forma:

class Univers():
    nom = ""
    apell = ""
    edad = ""
    dni = ""

alumno = Univers() #La instancia del objeto

Es posible consultar la clase de un objeto con la función type, pero también se puede consultar a través de su atributo especial __class__

print(alumno) #devuelve <__main__.Univers object at 0x054A01B0> que es una referencia al objeto
print( type(alumno) ) #devuelve <class '__main__.Univers'>
print(alumno.__class__) #devuelve <class '__main__.Univers'>

A su vez las clases tienen un atributo especial __name__ que nos devuelve su nombre en forma de cadena sin adornos:

print(Univers.__name__) #devuelve Univers
print( type(alumno).__name__ ) #devuelve Univers
print(alumno.__class__.__name__) #devuelve Univers

Es posible inicializar todas las variables para que tengan el tipo que queremos, para ello usaremos el constructor de la clase pasándole los argumentos que necesitemos

El constructor es un método que se llama automáticamente al crear un objeto y se define con el nombre __init__ y mediante la palabra reservada self podremos referenciar al objeto actual

class Univers():
    nom = ""
    apell = ""
    edad = ""
    dni = ""
    def __init__(self, nom, apell, edad, dni):
        self.nom = nom
        self.apell = apell
        self.edad = edad
        self.dni = dni

alumno = Univers("Juan", "Delgado", 12, 44565789) #La instancia del objeto

Si existe un constructor también debe existir un destructor que se llame al eliminar el objeto para que encargue de las tareas de limpieza como vaciar la memoria

Todos los objetos se borran automáticamente de la memoria al finalizar el programa, aunque para eliminarlos automáticamente disponemos del método especial __del__

No es aconsejable sobreescribir este método porque se maneja automáticamente, pero es interesante saber que es posible

class Univers():
    nom = ""
    apell = ""
    edad = ""
    dni = ""
    def __init__(self, nom, apell, edad, dni):
        self.nom = nom
        self.apell = apell
        self.edad = edad
        self.dni = dni
    def __del__(self):
        print("El alumno %s se está borrando de la memoria" %(self.nom) )

alumno = Univers("Juan", "Delgado", 12, 44565789) #La instancia del objeto
del(alumno) #Borramos el alumno de la memoria

El método __str__ es el que devuelve la representación de un objeto en forma de cadena

Se llama automáticamente es cuando imprimirmos una variable por pantalla con la función print

Por defecto los objetos imprimen su clase y una dirección de memoria, pero podemos cambiarlo sobreescribiendo su comportamiento

Por ejemplo, para el objeto universitario sobreescribimos el método __str__ para que nos muestre el nombre, edad, apellidos y dni

class Univers():
    nom = ""
    apell = ""
    edad = ""
    dni = ""
    def __init__(self, nom, apell, edad, dni):
        self.nom = nom
        self.apell = apell
        self.edad = edad
        self.dni = dni
    def __del__(self):
        print("El alumno %s se está borrando de la memoria" %(self.nom) )
    def __str__(self):
       return f"Alumno: {self.nom} Apellido: {self.apell} Edad: {self.edad} DNI: {self.dni}"

alumno = Univers("Juan", "Delgado", 12, 44565789) #La instancia del objeto
print( str(alumno) ) #muestra Alumno: Juan Apellido: Delgado Edad: 12 DNI: 44565789

Un método especial interesante es el que devuelve la longitud

Normalmente está ligado a colecciones, pero nada impide definirlo en una clase y no redefinirlo, porque por defecto no existe en los objetos aunque sea el que se ejecuta al pasarlos a la función __len__

En nuestro ejemplo del objeto universitario no tiene mucho sentido contar su longitud, pero lo incluyo para mostrar su uso

class Univers():
    nom = ""
    apell = ""
    edad = ""
    dni = ""
    def __init__(self, nom, apell, edad, dni):
        self.nom = nom
        self.apell = apell
        self.edad = edad
        self.dni = dni
    def __del__(self):
        print("El alumno %s se está borrando de la memoria" %(self.nom) )
    def __str__(self):
       return f"Alumno: {self.nom} Apellido: {self.apell} Edad: {self.edad} DNI: {self.dni}"
    def __len__(self):
       return 1

alumno = Univers("Juan", "Delgado", 12, 44565789) #La instancia del objeto
print( len(alumno) ) #muestra 1

Las propiedades de un objeto pueden describirse mediante otros objetos o incluso colecciones de ellos

class Nota_M():
    curso1 = 0.00
    curso2 = 0.00
    curso3 = 0.00
    final = 0.00
    def __init__(self,  curso1, curso2, curso3, final):
        self.curso1 = curso1
        self.curso2 = curso2
        self.curso3 = curso3
        self.final = final

class Univers():
    nom = ""
    apell = ""
    edad = ""
    dni = ""
    expediente = Nota_M(0.00, 0.00, 0.00, 0.00)
    def __init__(self, nom, apell, edad, dni, expediente):
        self.nom = nom
        self.apell = apell
        self.edad = edad
        self.dni = dni
        self.expediente = expediente
    def __del__(self):
        print("El alumno %s se está borrando de la memoria" %(self.nom) )
    def __str__(self):
       return f"Alumno: {self.nom} Apellido: {self.apell} Edad: {self.edad} DNI: {self.dni}"
    def __len__(self):
       return 1

nota_media = Nota_M(6.5, 7.95, 8.12, 7.23) #La instancia del objeto
alumno = Univers("Juan", "Delgado", 12, 44565789, nota_media) #La instancia del objeto

La definición de métodos asociados a un objeto puede precisarse en la definición del objeto

Por ejemplo, para el objeto universitario sobreescribimos el método __str__ para que muestre el nombre, edad, apellidos, dni y notas medias del alumno

Para acceder a las propiedades o a los métodos usaremos el operador .

class Nota_M():
    curso1 = 0.00
    curso2 = 0.00
    curso3 = 0.00
    final = 0.00
    def __init__(self,  curso1, curso2, curso3, final):
        self.curso1 = curso1
        self.curso2 = curso2
        self.curso3 = curso3
        self.final = final

class Univers():
    nom = ""
    apell = ""
    edad = ""
    dni = ""
    expediente = Nota_M(0.00, 0.00, 0.00, 0.00)
    def __init__(self, nom, apell, edad, dni, expediente):
        self.nom = nom
        self.apell = apell
        self.edad = edad
        self.dni = dni
        self.expediente = expediente
    def __del__(self):
        print("El alumno %s se está borrando de la memoria" %(self.nom) )
    def __str__(self):
       return f"Alumno: {self.nom} Apellido: {self.apell} Edad: {self.edad} DNI: {self.dni} Curso1: {self.expediente.curso1} Curso2: {self.expediente.curso2} Curso3: {self.expediente.curso3} Final: {self.expediente.final}"
    def __len__(self):
       return 1

nota_media = Nota_M(6.5, 7.95, 8.12, 7.23) #La instancia del objeto
alumno = Univers("Juan", "Delgado", 12, 44565789, nota_media) #La instancia del objeto
print( str(alumno) ) #muestra Alumno: Juan Apellido: Delgado Edad: 12 DNI: 44565789 Curso1: 6.5 Curso2: 7.95 Curso3: 8.12 Final: 7.23

Herencia

La herencia es la capacidad que tiene una clase de heredar los atributos y métodos de otra, algo que nos permite reutilizar código

Para ver su utilidad, vamos a desarrollar un ejemplo modificando el objeto universidad

Partiremos de una clase base que hará de padre (superclase) de otras hijas que heredaran de ella (subclases)

Partimos de una clase Persona que contendrá todos los atributos comunes y dos clases hijas Alumno y Profesor que heredan de ella y tienen atributos o métodos propios

Para heredar los atributos y métodos de una clase en otra sólo tenemos que pasarla entre paréntesis durante su definición

Es posible utilizar el comportamiento de una superclase sin definir nada en la subclase, aunque en nuestro ejemplo si que les daremos comportamiento

class Persona():
    nom = ""
    apell = ""
    edad = ""
    dni = ""
    def __init__(self, nom, apell, edad, dni):
        self.nom = nom
        self.apell = apell
        self.edad = edad
        self.dni = dni
    def __str__(self):
       return f"Persona: {self.nom} Apellido: {self.apell} Edad: {self.edad} DNI: {self.dni}"

class Nota_M():
    curso1 = 0.00
    curso2 = 0.00
    curso3 = 0.00
    final = 0.00
    def __init__(self,  curso1, curso2, curso3, final):
        self.curso1 = curso1
        self.curso2 = curso2
        self.curso3 = curso3
        self.final = final
    def __str__(self):
       return f"Curso1: {self.curso1} Curso2: {self.curso2} Curso3: {self.curso3} Final: {self.final}"
        
class Alumno(Persona):
    expediente = Nota_M(0.00, 0.00, 0.00, 0.00)
    def __init__(self, nom, apell, edad, dni, expediente):
        self.nom = nom
        self.apell = apell
        self.edad = edad
        self.dni = dni       
        self.expediente = expediente
    def __str__(self):
        return f"Alumno: {self.nom} Apellido: {self.apell} Edad: {self.edad} DNI: {self.dni} {str(self.expediente)}"

class Profesor(Persona):
    asignatura = ""
    def __init__(self, nom, apell, edad, dni, asignatura):
        self.nom = nom
        self.apell = apell
        self.edad = edad
        self.dni = dni       
        self.asignatura = asignatura
    def __str__(self):
        return f"Profesor: {self.nom} Apellido: {self.apell} Edad: {self.edad} DNI: {self.dni} Asignatura: {self.asignatura}"

nota_media = Nota_M(6.5, 7.95, 8.12, 7.23) #La instancia del objeto
alumno = Alumno("Juan", "Delgado", 12, 44565789, nota_media) #La instancia del objeto
profesor = Profesor("Pedro", "Del Río", 38, 19587426, "Ciencias naturales") #La instancia del objeto
print( str(alumno) ) #muestra Alumno: Juan Apellido: Delgado Edad: 12 DNI: 44565789 Curso1: 6.5 Curso2: 7.95 Curso3: 8.12 Final: 7.23
print( str(profesor) ) #muestra Profesor: Pedro Apellido: Del Río Edad: 38 DNI: 19587426 Asignatura: Ciencias naturales

Gracias a la flexibilidad de Python podemos manejar objetos de distintas clases masivamente de una forma muy simple

Vamos a empezar creando una lista con nuestros dos Personas de subclases distintas

personas = [alumno, profesor]
#Recorremos todos los elementos de la lista con un bucle for
for persona in personas:
    print(persona, "\n")
#También podemos acceder a los atributos, siempre que sean compartidos entre todos los objetos
for persona in personas:
    print(persona.nom, "\n")
#Si un objeto no tiene el atributo al que queremos acceder nos dará error
for persona in personas:
    #Usando la función isinstance() podemos comprobar si el atributo pertenece o no a un objeto concreto y evitar el error
    if( isinstance(persona, Profesor) ):
        print(persona.asignatura, "\n")

Uno de los pocos fallos de Python es que si modificamos los valores dentro de un objeto, estos cambios se verán reflejados fuera del mismo

De la misma forma que en las colecciones, los objetos se pasan a las funciones por referencia

Afecta a la hora de hacer copias, creándose en su lugar un acceso al objeto en lugar de uno nuevo con sus valores anteriores

Para realizar una copia a partir de sus valores podemos utilizar la función copy del módulo con el mismo nombre

alumno = Alumno("Juan", "Delgado", 12, 44565789, nota_media) #La instancia del objeto original
alumno2 = alumno
alumno2.nom = "Prueba"
print(alumno2 == alumno)  #¿Son el mismo objeto? Si, porque nos duelve True, el atributo nom debería ser igual en ambos objetos

try:
    print(alumno.nom) #devuelve 'Prueba'
    print(alumno2.nom) #devuelve 'Prueba'
except Exception as e:
    print(e)
    
alumno = Alumno("Juan", "Delgado", 12, 44565789, nota_media) #volvemos a cargar la instancia del objeto original

from copy import copy

alumno2 = copy(alumno)
alumno2.nom = "Prueba"
print(alumno2 == alumno)  #¿Son el mismo objeto? No, porque nos devuelve False, el atributo nom debería ser distinto en ambos objetos

try:
    print(alumno.nom) #devuelve 'Juan'
    print(alumno2.nom) #devuelve 'Prueba'
except Exception as e:
    print(e)

La función copy se puede utilizar también para copiar colecciones

from copy import copy

lista1 = [1,2,3]
lista2 = copy(lista1)
lista1 = None

print(lista1) #devuelve None
print(lista2) #devuelve [1, 2, 3]

La herencia múltiple permite a una subclase heredar de múltiples superclases

Esto conlleva un problema, y es que si varias superclases tienen los mismos atributos o métodos, la subclase sólo podrá heredar de una de ellas

Además de superclases también puede heredar de forma múltiple de subclases

En estos casos Python dará prioridad a las clases más a la izquierda en el momento de la declaración de la subclase

class Profesor_Alumno(Profesor, Alumno):
    pass

nota_media = Nota_M(6.5, 7.95, 8.12, 7.23) #La instancia del objeto
alumno = Alumno("Juan", "Delgado", 12, 44565789, nota_media) #La instancia del objeto
profesor = Profesor("Pedro", "Del Río", 38, 19587426, "Ciencias naturales") #La instancia del objeto
profesor_alumno = Profesor_Alumno("Pedro", "Del Río", 38, 19587426, "Ciencias naturales") #Usará como superclase Profesor
print(profesor_alumno) #Devuelve Alumno: Pedro Apellido: Del Río Edad: 38 DNI: 19587426 Asignatura: Ciencias naturales
profesor_alumno = Profesor_Alumno("Pedro", "Del Río", 38, 19587426, nota_media) #Usará como superclase Alumno
print(profesor_alumno) #devuelve Alumno: Pedro Apellido: Del Río Edad: 38 DNI: 19587426 Asignatura: Curso1: 6.5 Curso2: 7.95 Curso3: 8.12 Final: 7.23

Hemos usado la palabra reservada pass para indicarle al intérprete que ignore el código del cuerpo y utilice el de la clase object o el de las superclases (subclases) que le indiquemos

Valor nulo

En Python a las variables se les puede asignar un valor que indica el valor vacío, este valor es el valor NULL

Una variable es considerada None si:

• se le ha asignado la constante None
• no se le ha pasado un atributo a una función

La constante None es insensible a mayúsculas o minúsculas

var = None

print(var) #devuelve None