<jupyter_start><jupyter_text>Clases y Objetos en Python     ¡Bienvenido!     Los objetos en programación son parecidos a los de la vida real. Al igual que los reales, hay distintos tipos de objetos. En este cuaderno, crearemos dos clases llamadas Circulo y Rectángulo. Al final, tendrás una idea mas clara acerca de:            Qué es una clase        Qué es un atributo        Qué es un método    No te preocupes si no lo entiendes la primera vez ya que la terminología es confusa. No olvides hacer los exámenes de este cuaderno. Tabla de Contenido                        Introducción a las Clases y Objetos                            Crear una Clase                Instancias de la Clase: Objetos y Atributos                Métodos                            Crear una Clase        Crear una instancia de la clase Circulo        La Clase Rectángulo                Tiempo Estimado: 40 min     Introducción a las Clases y Objetos Crear una Clase Lo primero al crear una clase es darle un nombre: En este cuaderno, crearemos dos clases, Circulo y Rectángulo. Tenemos que determinar los datos necesarios para hacer esa clase, a esos datos le llamamos atributos. Puedes pensar en este paso como la creación de un plano que después usaremos para construir objetos. En la imagen 1 podemos ver dos clases, circulo (Circle) y rectángulo (Rectangle). Cada una posee atributos, en forma de variables. La clase circulo tiene los atributos: radius y color, la clase rectángulo posee los atributos height y width (altura y ancho en inglés respectivamente). Usemos algunos ejemplos visuales de estas figuras antes de ver el código, esto ayudara a que te familiarices con el vocabulario.   Figura 1: Clases circle y rectangle, cada una tiene sus atributos. La clase circle tiene los atributos radius y colour, la clase rectángulo posee los atributos height y width (altura y ancho en inglés respectivamente). Instancias de la Clase: Objetos y Atributos Una instancia de objeto es producto de una clase, en la figura 2 podemos ver tres instancias de la clase circle. Le damos a cada objeto el nombre: red circle (círculo rojo), yellow circle (círculo amarillo) y green circle (círculo verde). Cada uno tiene distintos atributos, enfoquémonos por ahora en el atributo colour (color) de cada objeto.  Figura 2: Tres instancias de la clase circle o, dicho de otra forma, tres objetos de tipo circle. El atributo colour para el círculo rojo es el color rojo, para el círculo verde será el verde y amarillo para el círculo amarillo. Métodos Los métodos permiten cambiar o interactuar con el objeto; los métodos son funciones que interactúan con los objetos. Por ejemplo, digamos que queremos incrementar el radio (radius) de un círculo. Podemos crear un método llamado **add_radius(r)** que incremenete el radio por **r**. Esto se muestra en la figura 3, donde después de usar el método al objeto “orange circle”, el radio aumenta. El “punto” significa que el método será aplica a ese objeto, que en esencia es ejecutar una función sobre la información del objeto.   Figura 3: Aplicar el método “add_radius” al objeto “orange circle”.  Crear una Clase Creemos ahora una clase circle, pero primero, importemos una librería para dibujar objetos:<jupyter_code># Importar la librería

import matplotlib.pyplot as plt
%matplotlib inline<jupyter_output><empty_output><jupyter_text>El primer paso en la creación de nuestra clase es usar la palabra reservada class, y después el nombre de la clase como se muestra en la figura 4. En este curso la clase padre será siempre objeto:  Figura 4: Tres instancias de la clase circle o, dicho de otra forma, tres objetos de tipo circle. El siguiente paso es el método especial llamado constructor \__init\_\_, que es usado para inicializar el objeto. La entrada son datos para los atributos. El termino self contiene todos los atributos del grupo. Por ejemplo self.color asigna el valor del atributo color y self.radius valor del radio. También tenemos el método add_radius() con el parámetro r, el método suma el valor de r al atributo radius. Para acceder al valor de radius usamos la sintaxis self.radius. El etiquetado se resume en la Figura 5.  Figura 5: Sintaxis del objeto circle. El objeto actual se muestra mas adelante. Incluimos el método drawCircle para mostrar la imagen de un circulo. Asignamos el valor de radius en 3 y el color en azul (blue):<jupyter_code># Crear la clase Circle

class Circle(object):
    
    # Constructor
    def __init__(self, radius=3, color='blue'):
        self.radius = radius
        self.color = color 
    
    # Method
    def add_radius(self, r):
        self.radius = self.radius + r
        return(self.radius)
    
    # Method
    def drawCircle(self):
        plt.gca().add_patch(plt.Circle((0, 0), radius=self.radius, fc=self.color))
        plt.axis('scaled')
        plt.show()<jupyter_output><empty_output><jupyter_text>Crear una instancia de la clase Circulo Vamos a crear el objeto RedCircle de tipo Circle para hacer lo siguiente:<jupyter_code># Crear un objeto RedCircle

RedCircle = Circle(10, 'red')
print(RedCircle)<jupyter_output><__main__.Circle object at 0x7f93685b0e10><jupyter_text>Podemos usar el comando dir para obtener una lista de los métodos del objeto. Muchos de ellos son métodos por defecto de Python.<jupyter_code># Obtener los métodos que pueden usarse en el objeto RedCircle

dir(RedCircle)<jupyter_output><empty_output><jupyter_text>Veamos el valor de los atributos del objeto:<jupyter_code># Imprime el atributo radius del objeto

RedCircle.radius
# Imprime el atributo color del objeto

RedCircle.color<jupyter_output><empty_output><jupyter_text>Podemos cambiar el valor de los atributos del objeto:<jupyter_code># Asigna un valor al atributo radius

RedCircle.radius = 1
RedCircle.radius
RedCircle.color = "yellow"
RedCircle.color<jupyter_output><empty_output><jupyter_text>Dibujamos el objeto usando el método drawCircle():<jupyter_code># Llamada al método drawCircledata:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAQ0AAAD4CAYAAAD2OrMWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAZCElEQVR4nO3debgcZZXH8e9JSFAhgpDIDgE<KEY>EUEgREQGRFkQH3EAANuw6i4IYwKDuLooAIGZAAXGFzAsG8OiwoMCWaVHVFDIkHAhMURAmf+eOuS5qb73q5by1vL7/M8/XTfrqVP9e0+/VbVW+8xd0dEpF9jYgcgIvWipCEiqShpiEgqShoikoqShoikslLsAEZj4sSJPnny5NhhiDTWzJkz/+Luk7pNq2XSmDx5MjNmzIgdhkhjmdkfek3T7omIpKKkISKpKGmISCpKGiKSipKGiKSSS9Iws/PMbLGZzesx3czsDDN7wMzmmNl2HdP2NrN7k2kn5BGPiBQnr5bG+cDew0zfB9g0uU0FzgIws7HAd5PpWwKHmtmWOcUkIgXIJWm4+y3AE8PMcgBwoQe3A6ub2TrAFOABd3/I3Z8DLk7mFZGKKqtz13rAnzr+XpA81+35N3dbgZlNJbRS2HDDDYuJUlJYCiwCFg65XwQ<KEY>

RedCircle.drawCircle()<jupyter_output><empty_output><jupyter_text>Podemos incrementar el radio del circulo utilizando el metodo add_radius(). Incrementémoslo a 2 y después a 5:<jupyter_code># Usar el método para modificar el atributo radius

print('Radius of object:',RedCircle.radius)
RedCircle.add_radius(2)
print('Radius of object of after applying the method add_radius(2):',RedCircle.radius)
RedCircle.add_radius(5)
print('Radius of object of after applying the method add_radius(5):',RedCircle.radius)<jupyter_output>Radius of object: 1
Radius of object of after applying the method add_radius(2): 3
Radius of object of after applying the method add_radius(5): 8<jupyter_text>Vamos a crear un circulo azul. Su color por defecto será azul (blue), solo debemos especificar el valor que queremos darle al radio:<jupyter_code># Crear un círculo azul con un radio especifico

BlueCircle = Circle(radius=100)<jupyter_output><empty_output><jupyter_text>Al igual que antes, también podemos acceder los atributos de una instancia al usar el punto ( . ):<jupyter_code># Imprimir el atributo radius del objeto

BlueCircle.radius
# Imprimir el atributo color del objeto

BlueCircle.color<jupyter_output><empty_output><jupyter_text>Podemos dibujar el objeto utilizando el método drawCircle():<jupyter_code># Llamada al método drawCircle

BlueCircle.drawCircle()<jupyter_output><empty_output><jupyter_text>Compara el eje “x” y “y” de la figura RedCircle; veras que son distintos.  La Clase Rectángulo Vamos a crear una clase rectángulo con los atributos height (altura) y color. Solo añadiremos el método para dibujar un rectángulo:<jupyter_code># Crear una nueva clase Rectangle para construir un objeto rectangulo

class Rectangle(object):
    
    # Constructor
    def __init__(self, width=2, height=3, color='r'):
        self.height = height 
        self.width = width
        self.color = color
    
    # Method
    def drawRectangle(self):
        plt.gca().add_patch(plt.Rectangle((0, 0), self.width, self.height ,fc=self.color))
        plt.axis('scaled')
        plt.show()<jupyter_output><empty_output><jupyter_text>Creamos el objeto SkinnyBlueRectangle de tipo Rectangle. Su anchura (width) será de 2 y la altura (height) de 3, será de color azul:<jupyter_code># Crear un nuevo objeto rectangle

SkinnyBlueRectangle = Rectangle(2, 10, 'blue')<jupyter_output><empty_output><jupyter_text>Al igual que antes, también podemos acceder los atributos de una instancia al usar el punto ( . ):<jupyter_code># Imprimir el atributo height (altura en inglés) del objeto

SkinnyBlueRectangle.height 
# Imprimir el atributo width (anchura en inglés) del objeto

SkinnyBlueRectangle.width
# Imprimir el atributo color del objeto

SkinnyBlueRectangle.color<jupyter_output><empty_output><jupyter_text>Podemos dibujar el objeto:<jupyter_code># Usar el método drawRectangle para dibujar la figura

SkinnyBlueRectangle.drawRectangle()<jupyter_output><empty_output><jupyter_text>Vamos a crear el objeto FatYellowRectangle\</code del tipo Rectangle:<jupyter_code># Crear un nuevo objeto rectangle

FatYellowRectangle = Rectangle(20, 5, 'yellow')<jupyter_output><empty_output><jupyter_text>We can access the attributes of the instance of the class by using the dot notation:<jupyter_code># Imprimir el atributo height (altura en inglés) del objeto

FatYellowRectangle.height 
# Imprimir el atributo width (anchura en inglés) del objeto

FatYellowRectangle.width
# Imprimir el atributo color del objeto

FatYellowRectangle.color<jupyter_output><empty_output><jupyter_text>Podemos dibujar el objeto:<jupyter_code># Usar el método drawRectangle para dibujar la figura

FatYellowRectangle.drawRectangle()<jupyter_output><empty_output><jupyter_text>Ejercicios Analisis de Texto  Su amigo, un entusiasta de la lingüística, lo contrató para crear una herramienta de utilidad que pueda realizar análisis en un texto determinado. Complete la clase 'analysedText' con los siguientes métodos: -     Constructor: toma el argumento 'text', lo pone en minúsculas y elimina toda la puntuación. Suponga que solo se utiliza la siguiente puntuación: punto (.), Signo de exclamación (!), Coma (,) y signo de interrogación (?). Almacene el argumento en "fmtText"           freqAll: devuelve un diccionario de todas las palabras únicas en el texto junto con el número de apariciones.     freqOf: devuelve la frecuencia de la palabra pasada en el argumento. Se le ha dado el código esqueleto. Las cadenas de documentos se pueden ignorar a los efectos del ejercicio.    ugerencia: algunas funciones útiles son replace(), lower(), split(), count()<jupyter_code>class analysedText(object):
    
    def __init__ (self, text):
        pass
        fmtText = self.text
    
    def freqAll(self):        
        pass
    
    def freqOf(self,word):
        pass
        
class analysedText(object):

    def __init__ (self, text):
        textoTrabajado = text.lower()
        textoTrabajado = textoTrabajado.replace("."," ")
        textoTrabajado = textoTrabajado.replace("!"," ")
        textoTrabajado = textoTrabajado.replace(","," ")
        textoTrabajado = textoTrabajado.replace("?"," ")
        
        self.fmtText = textoTrabajado
    
    def freqAll(self):        
        listaPalabras = self.fmtText.split(" ")
        aux={}
        for e in set(listaPalabras):
            aux[e] = listaPalabras.count(e)
            return aux
    
    def freqOf(self,word):
        conteo = self.freqAll()
        
        if e in conteo:
            return conteo[e]
        else:
            return 0<jupyter_output><empty_output><jupyter_text>Ejecute el bloque a continuación para verificar su progreso.<jupyter_code>import sys

sampleMap = {'eirmod': 1,'sed': 1, 'amet': 2, 'diam': 5, 'consetetur': 1, 'labore': 1, 'tempor': 1, 'dolor': 1, 'magna': 2, 'et': 3, 'nonumy': 1, 'ipsum': 1, 'lorem': 2}

def testMsg(passed):
    if passed:
       return 'Test Passed'
    else :
       return 'Test Failed'

print("Constructor: ")
try:
    samplePassage = analysedText("Lorem ipsum dolor! diam amet, consetetur Lorem magna. sed diam nonumy eirmod tempor. diam et labore? et diam magna. et diam amet.")
    print(testMsg(samplePassage.fmtText == "lorem ipsum dolor diam amet consetetur lorem magna sed diam nonumy eirmod tempor diam et labore et diam magna et diam amet"))
except:
    print("Error detected. Recheck your function " )
print("freqAll: ")
try:
    wordMap = samplePassage.freqAll()
    print(testMsg(wordMap==sampleMap))
except:
    print("Error detected. Recheck your function " )
print("freqOf: ")
try:
    passed = True
    for word in sampleMap:
        if samplePassage.freqOf(word) != sampleMap[word]:
            passed = False
            break
    print(testMsg(passed))
    
except:
    print("Error detected. Recheck your function  " )<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.06708626434653832, 'fraction_numerical': 0.011106997408367271, 'mean_word_length': 4.393769968051118, 'pattern_counts': {'":': 0, '<': 83, '<?xml version=': 0, '>': 82, 'https://': 0, 'lorem ipsum': 1, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 2, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '20', 'dir': 'jupyter-structured-clean-dedup', 'id': '413052', 'license': 'MIT', 'n_tokens_mistral': 4781, 'n_tokens_neox': 4659, 'n_words': 1522, 'path': 'M3/PY0101ES-3-4-Clases .ipynb', 'repo_name': 'Fragusan/Python-101', 'size': '21582'}