Programación orientada a objetos en Python

new() - es el responsable de** crear la instancia**, devuelve como objecto la instancia referencia. Cuando finaliza la ejecución del new, se procede a la llamada el method ini().

Cuando se construye un objeto, se inicializa invocando al método init.

Cuando leemos nuestro código decimos “dunder init” cada vez que nos encontramos con la cadena de caracteres init.

En inglés:

When a new object is made, it is initialized by calling the init method on the object. init is pronounced “dunder init”: dunder is short for “double-underscore”.

El self, para los que vengan de JS, funciona como el this keyword.

Me alegra haber aprendido POO en Java, sino estaría muy confundido en este momento, como lo estuve cuando lo vi por primera vez.

Encontré este ejemplo de decoradores en metodos, es pero que les sea de ayuda.

def p_decorate(func):
   def func_wrapper(*args, **kwargs):
       return "<p>{0}</p>".format(func(*args, **kwargs))
   return func_wrapper

class Person():
    def __init__(self):
        self.name = "John"
        self.family = "Doe"

    @p_decorate
    def get_fullname(self):
        return self.name+" "+self.family

my_person = Person()

print(my_person.get_fullname())

referencia:
thecodeship

utiliza new cuando quieras controlar la creación del objeto
utiliza init cuando quieras gestionar la inicialización del objeto

new es lo primero que se ejecuta cuando se instancia una clase y es el responsable de devolver una instancia de esa clase.
init no devuelve nada y solo se encarga de inicializar los valores iniciales del objeto

Upper Case: Todas las letras del identificador se encuentran en mayúsculas, por ejemplo: EJEMPLODENOMENCLATURA. Es usado, por ejemplo, para las constantes definidas en PHP.


Camel Case: El nombre viene porque se asemeja a las dos jorobas de un camello, y se puede dividir en dos tipos:
– Upper Camel Case, cuando la primera letra de cada una de las palabras es mayúscula. También denominado Pascal Case. Ejemplo: EjemploDeNomenclatura.
– Lower Camel Case, igual que la anterior con la excepción de que la primera letra es minúscula. Ejemplo: ejemploDeNomenclatura.
Es muy usada en los #hashTags de Twitter o en lenguajes como Java, PHP, C#…


Snake Case: Cuando cada una de las palabras, se separa por un guión bajo (_). Es común en los nombres de variables y funciones de lenguajes como C, aunque también Ruby y Python lo han adoptado. Como el Camel Case existen variedades, como todas las letras en mayúsuculas, denominado SCREAMING_SNAKE_CASE, que se utiliza para definir constantes. Ejemplo: ejemplo_de_nomenclatura


Kebab Case: Es igual que el Snake Case, esta vez, son guiones medios (-) los que separan las palabras. Su uso más común es de las urls. Ejemplo: ejemplo-de-nomenclatura

Este es el código que se vió en la clase con algunas modificaciones simples para hacer un poco más interactivo:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def say_hello(self):
        print(f'Hello, my name is {self.name} and I am {self.age} years old')


if __name__ == '__main__':
    name = input('What is your name? ')
    age = int(input('What is your age? '))

    person = Person(name, age)

    print(f'Age: {person.age}')
    person.say_hello()

Muy buen curso Platzi y David Aroesti

Documentación: https://docs.python.org/3/tutorial/classes.html

class Persona:
    def __init__(self, name,age):
        self.name=name
        self.age=age
        
    def say_hello(self):
        print('Hola , mi nombre es {} , y tengo {} años' .format(self.name,self.age))


if __name__ == "__main__":
    _nombre= input('porfavor digite su nombre')
    _edad= input('porfavor digite su edad')
    persona_= Persona(_nombre,_edad)
    persona_.say_hello()```

La realidad es que el método init crea el objeto y luego lo inicializa, no es el constructor como tal, en cambio el método new sólo construye el objeto.

Python, new se usa cuando necesita controlar la creación de una nueva instancia, mientras que init se usa cuando necesita controlar la inicialización de una nueva instancia.

new es el primer paso de la creación de la instancia. Se llama primero y es responsable de devolver una nueva instancia de su clase.

Por el contrario, init no devuelve nada; solo es responsable de inicializar la instancia después de que se haya creado.

https://seraph13.medium.com/volviendo-a-lo-básico-poo-en-python-diferencia-entre-init-y-new-parte-10-3ec7632388d1#:~:text=Muchos que han programado orientado,__ sólo construye el objeto.

https://dev.to/pila/constructors-in-python-init-vs-new-2f9j#:~:text=new%20is%20the,instance%20after%20it’s%20been%20created.

El método init crea el objeto y luego lo inicializa, no es el constructor como tal, en cambio el método new sólo construye el objeto.
Referencia:
https://medium.com/@_seraph1/volviendo-a-lo-básico-poo-en-python-diferencia-entre-init-y-new-parte-10-3ec7632388d1

si no está muy claro:
https://www.youtube.com/watch?v=5Ohme4A2Weg&list=PLU8oAlHdN5BlvPxziopYZRd55pdqFwkeS&index=24

El init, es un método muy esencial además también de que siempre tenemos que tener el kw self, para referirnos a la clase misma.

El metodo init es como el constructor que usamos en Java.

El new(dunder new). Se utiliza muy poco sin embargo tiene el proposito de usarse cuando se hacen subclases de de tipos inmutables como lo son las tuplas y los string.

Aqui les dejo una guia ligera!
https://rszalski.github.io/magicmethods/

el “self” funciona como el “this” de otros lenguajes como Java.

Aquí un hilo sobre el minuto 6:42

https://medium.com/@_seraph1/volviendo-a-lo-básico-poo-en-python-diferencia-entre-init-y-new-parte-10-3ec7632388d1

dunder methods-----> https://dbader.org/blog/python-dunder-methods

new(cls, args)
Método exclusivo de las clases de nuevo estilo que se ejecuta antes que init y que se encarga de construir y devolver el objeto en sí. Es equivalente a los constructores de C++ o Java. Se trata de un método estático, es decir, que existe con independencia de las instancias de la clase: es un método de clase, no de objeto, y por lo tanto el primer parámetro no es self, sino la propia clase: cls.

4hrs de Anahi en Java en 15m con David en Python. Na mentiras gracias a todo lo que he cursado se me ha facilitado más con david.

class Persona:

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def say_hello(self):
        print("Hello, my is {} and I am {} years old".format(self.name, self.age))

if __name__ == "__main__":
    person = Persona("David", 34)

    print("Age: {}".format(person.age))
    person.say_hello()

Qué es self en Python

Útil: https://howto.lintel.in/python-new-magic-method-explained/
pare ser una opción de personalizar la creación del objeto, lo utilizas antes del init

Buenas tardes,

Existe sobrecarga de constructores?

Aprender Clases y Objetos con Java, facilita mucho la lógica. Con Python es mucho más sencillo declarar las clases y objetos y pasar las herencias y los métodos correspondientes. Python es un gran lenguaje, de verdad estoy muy feliz por este curso

Mi código, creando una clase Person, inicializando como un cliente y llamando una función que se encarga de devolver todos los datos para mostrarlos por pantalla.

El ejemplo estuvo muy básico pero creo que se entendio bien lo que David queria comunicar.

Camel Case para los que NO sepan consiste en poner la primera letra de cada palabra, del nombre de la clase en este caso, en MAYUSCULA

En python se utilizan los getters y setters?

Class Ejemplo:
def init():

init inicializa la clase de acuerdo a los parámetros iniciales

Genial!! Me encanta este lenguaje!

me hubiese gustado que explicaras mas detalles, porque cuando dices que es una propiedad en verdad es un campo o attribute, algo diferente a una property

init = constructor

El uso del init y el new mas explicado en el siguiente link https://www.code-learner.com/how-to-use-python-new-method-example/

Si no te quedo bien claro el concepto de las clases puedes ayudarte con este par de videos que me sirvieron de mucha ayuda, ya que estos conceptos son nuevos para mi.

https://www.youtube.com/watch?
v=vdz9HGfFguc&list=PLpOqH6AE0tNiK7QN6AJo_3nVGQPc8nLdM&index=31

Es una lista completamente desde 0, desde el mismo video pueden ir profundizando mas ustedes. Saludos!

class Persona:
    def __init__(self, nombre, edad):
        self.nombre = nombre
        self.edad = edad

    def say_hello(self):
        print(f'hola, mi nombre es: {self.nombre} y tengo { self. edad} años')

if __name__ == '__main__':

    name = input('¿Cuál es tu nombre?')
    age = input('¿Cuantos años tienes?')

    person = Persona(name,age)

    # print(f'hola {edad}')
    person.say_hello()

Cada vez que llamamos a una clase estamos generando una instancia

Java me resulta un lenguaje mas duro de aprender pero conocerlo me ha hecho super fácil pasar a POO con Python, es cuestión de conocer la sintaxis.

init crea el objeto y lo inicializa

No esta bien que se pueda acceder a los atributos de una clase de una forma directa, por esto se debe programar funciones que permitan obtener por este medio los atributos que se necesiten.

self: Es una referencia a la clase, es un forma para acceder a las propiedades y métodos de la clase.

investigando lo del método new, según la documentación de Python es “sí new es invocada en la construcción de un objeto y devuelve la instancia o subclase de cls, entonces el metodo de la nueva instancia init() será invocada como init(self[, …]), donde self es la nueva instancia y los demas argumentos son los mismos que fueron pasados al contructor de objetos” creo que lo explica muchísimo mejor el compañero Franck Sanchez.

Magic / dunder methods

Creo que es muy interesante estos métodos de doble guión bajo o dunder methods, tal como se dijo en el principio del curso, estos vienen con una función preestablecida, pero lo interesante esta, que si los colocas en el constructor de objetos y modificas como se comportarán estos harán lo que les pidas, un ejemplo que conseguí es que si usas el add(), cambias la forma en la que funcionará este método dentro de tu objeto, Ejemplo:

#Tenemos la clase persona
class Person:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

    def say_hello(self):
        print(f'Hello my name is {self.name} and I am {self.age} years old')


if __name__ == '__main__':
    person = Person('David', 34)
    print(len(person.name)) #Imprime 5 que es la cantidad de caracteres de David

Ahora deseamos que el dunder method len haga que nos de la cantidad de caracteres que tiene el nombre completo de la persona (nombre + apellido) y no sólo el nombre, entonces

    def __init__(self, name, age):   #agregamos el apellido a la persona
        self.name = name
        self.age = age

    def full_name(self):
        return (f'')
    def say_hello(self):
        print(f'Hello my name is {self.name} and I am {self.age} years old')


if __name__ == '__main__':
    person = Person('David', 34)
    print(len(person.name))

Esto imprime en consola

David Aroesti
Hello my name is David and I am 34 years old
13 

13 es la suma de el len de David Aroesti y la obtenemos porque modificamos como funciona el dunder method len

para otros ejemplos y una explicación más detallada de los dunder methods está en inglés.

Hacemos la dot notation para acceder a las propiedades de una clase o algunos de sus valores. Los mismo que sus métodos, punto y luego nombre del método junto con los paréntesis.

Dentro de nuestras clases. el __init__ nos dice los parámetros para crear un objeto.

Para crear una instancia, lo único que tenemos que hacer es simplemente, inicializar la variable y llamar dentro de la variable nuestra clase con su nombre, si esta tiene parámetros de inicialización, entonces los declaramos también, y ya.

No accedas a las demás variables privadas.

Las variables privadas en Python, inician con una barra baja, igual que las funciones privadas.

Tenemos dentro del Dunder init, varias declaraciones de variables internas, algo como: self.golpear = golpear.

Luego de la definición de la clase, es el método __init__ o dunder init. los métodos se declaran cómo funciones. este método nos ayuda a inicializar la clase, basado en los parámetros que nos han dado cuándo la clase se construyó.

Para empezar nuestra clase, tenemos que usar el Keyword Class y luego el nombre del keyword de la clase, pero este a diferencia de la variable, sí tiene uppercase y su notación sería CamelCase. Empezamos con Mayúscula.

Python es un lenguajes de convenciones.

Por que es malo ingresar a esas variables o funciones que tienen _ _ , Realmente esto viene mas que todo de la etica del programador realmente dentro de python lo puedes hacer sin problema solamente que ese tipo de cosas se utiliza para convensiones de seguirdad a las cosas que veas de esta forma sabes que cosas puedes manejar y que otras cosas no, en otros lenguajes de programacion si estan un poco mas establecidas estas reglas con keywords predefinidas para las mismas, a la final sera lo mismo ya sea trabajar con una variable que sea protect o algo que tenga _

excelente clase

Muy buena clase explicando puntualmente como se genera una clase y una instancia.

class Person:

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def say_hello(self):
        print('Hello, my name is {} and I am {} years old'.format(self.name, self.age))


if __name__ == '__main__':
    person = Person('Frank', '35')

    print('The user {} have {} years old'.format(person.name, person.age))
    person.say_hello()

• Las clases se declaran con keyword class y por convención empiezan con la letra en Mayúscula.
• El constructor de la clase, inicia los valores de la clase, se implementa con la fucción __init__(self, params).
• self, hace referencia a la misma clase.