Clases y objetos avanzados de Python

clase

Atributo de clase

Atributo de clase: puede ser compartido por el objeto de instancia de clase actual, que es llamado por el nombre de la clase,
similar a la variable estática de la clase.

class Student:
	# 所有类实例对象都可以操作
	school='牛津大学'

print(Student.school)

Método de clase

Método de clase: similar a un método estático, llamado por el nombre de la clase, debe agregar un modificador @classmethod
para manipular los atributos de la clase. El
parámetro predeterminado clsrepresenta la clase actual, que clses la abreviatura de clase

class Student:
	# 类属性
	school='牛津大学'
	
	# 类方法
	@classmethod
	def printSchool(cls):
		print(cls.school)

Método estático

Método estático: similar al método de clase, la diferencia es que el atributo de la clase actual no se puede llamar, no hay un atributo predeterminado clsy también es llamado por el nombre de la clase. El
modificador @staticmehtod
generalmente define algunos métodos que no están relacionados con el clase.

class Student:

	@staticmethod
	def caculate(a,b):
	'''
	计算参数a和参数b的和
	'''
	return a+b

Objeto

Constructor

En Python, se llaman a todos los constructores de clases __init__y todos los métodos de instancia tienen un parámetro predeterminado self. No es necesario que selfasignemos valores a los parámetros pasados. selfRepresenta el objeto actual y el intérprete lo interpreta automáticamente.

class Student:
	
	def __init__(self,name,age):
		'''
		第一参数必须是self
		通过self.的方式创建对象属性
		下面实例给student对象创建两个对象属性name,age
		'''
		self.name=name
		self.age=age

stu=Student('张三',18)

Propiedades / métodos privados

Python no tiene un control de acceso estricto sobre los miembros de la clase, que es diferente de otros orientados a objetos. Existen los siguientes puntos sobre propiedades privadas y métodos privados:

1. Por lo general, estamos de acuerdo en que los atributos que comienzan con los dos guiones bajos son privados y los demás son públicos
2. No se puede acceder directamente a propiedades o métodos privados fuera de la clase
3. Se puede acceder directamente a las propiedades o métodos privados dentro de la clase
4. El exterior de la clase puede acceder a atributos o métodos privados a través de "_nombre de clase__nombre de atributo (método) privado"

class Person:

    def __init__(self,name,age):
        self.__name=name
        self.__age=age
    
    def toString(self):
        '''
        在类内部访问类的私有属性
        '''
        print('name:{0}age:{1}'.format(self.__name,self.__age))

p=Person('张三',18)
p.toString()

'''
一定要非法访问，可以通过_类名__属性名的方式访问
'''
print(p._Person__name)
print(p._Person__age)
'''
在外部直接访问私有属性会直接报错的
'''
print(p.__name)

class Person:

    def __init__(self):
        print('构造方法被执行了')
        self.__work()
    
    def __work(self):
        '''
        私有方法
        '''
        print('我会努力工作')
    
p=Person()
p.__work()

método getter / setter

Forma normal

'''
普通方式给类属性设置get和set方法
'''
class Person:

    def __init__(self,name):
        '''
        构造方法
        '''
        # 属性一定要私有化
        self.__name=name

    def set_name(self,name):
        self.__name=name
    
    def get_name(self):
        return self.__name

p=Person('李四')
print(p.get_name())
p.set_name('张三')
print(p.get_name())

Usa decorator @property para simplificar

El decorador @property puede hacer que la llamada al método sea como una propiedad

class Person:

    def __init__(self,salay):
        # 属性必须私有化
        self.__salay=salay

    @property
    def salay(self):
        '''
        get方法
        '''
        return self.__salay

    @salay.setter
    def salay(self,salay):
        '''
        set方法
        '''
        if salay>0:
            self.__salay=salay
        else :
            print('输入值不能低于0')

p=Person(3000)
print(p.salay)
p.salay=-2000
print(p.salay)
p.salay=8000
print(p.salay)

Método de objeto (instancia)

Todos los métodos de instancia tienen un parámetro predeterminado self, no necesitamos selfasignar un valor al parámetro pasado, que selfrepresenta el objeto actual, y el intérprete interpreta automáticamente el
método de llamada: nombre de instancia. Nombre del método

class Student:
	
	def __init__(self,name,age):
		'''
		第一参数必须是self
		通过self.的方式创建对象属性
		下面实例给student对象创建两个对象属性name,age
		'''
		self.name=name
		self.age=age

	def toString(self):
		'''
		打印name和age
		'''
		print('name={0},age={1}'.format(self.name,self,age))
	

stu=Student('张三',18)

Incinerador de basuras

__del__Los métodos se denominan destructores en Python y se utilizan para implementar las operaciones necesarias cuando se destruye el objeto.
Python se da cuenta de 自动的垃圾回收que cuando el objeto no está referenciado (cuando el contador de referencia es 0), el recolector de basura llama a la __del__función del objeto.
También podemos deleliminar el objeto a través de la palabra clave , para lograr el __del__método de llamada .
Generalmente, el sistema proporciona automáticamente un __del__método. Definir método destructor

class Student:
    
    def __init__(self):
        '''
        构造函数
        '''
        print('初始化一个student对象'+str(id(self)))
        pass

    def __del__(self):
        '''
        析构函数
        '''
        print('id:'+str(id(self))+'被销毁')

stu01=Student()
stu02=Student()

resultado

Función de llamada de objeto y objeto invocable

Cada objeto tiene una callfunción, que 对象名()se llama de forma

class Person:
    def __init__(self):
        '''
        构造函数
        '''
        print('创建了一个对象：'+str(self))

    def __call__(self,salary):
        '''
        call函数
        '''
        yearsSalary=salary*12
        daySalary=salary//27.5

        return {
    
    
            'yearsSalary':yearsSalary,
            'daySalary':daySalary
        }

p=Person()

print(p(3000))

Sobrecarga de métodos

No hay sobrecarga de métodos en Python. Python no admite la sobrecarga.
Hay varios métodos con el mismo nombre. Solo el último método es válido y el resto no lo son.

class Student:

    def hello(self):
        print('hello world')


    def hello(self,message):
        print(message)
    
stu=Student()
stu.hello()

resultado

La dinámica de Python

Agregue métodos dinámicamente a la clase

class Person:

    def work(self):
        print('努力工作')

# 在类的外面定义个方法
def play_games(s):
    print(str(id(s))+'愉快的玩游戏')

# 将玩游戏这个方法添加给Person
Person.play_game=play_games

p=Person()
p.work()
p.play_game()

Modificar dinámicamente métodos para clases

class Person:

    def work(self):
        print('努力工作')

# 在类的外部定义一个work方法
def works(s):
    print(str(id(s))+'说：好好工作，努力学习')

# 将person的work赋值等于work()方法
Person.work=works

p=Person()
p.work()
	

función isinstance

Parámetro 1: Objeto
Parámetro 2: Clase
Función: Se usa para juzgar si el objeto actual pertenece a la clase actual

class Student:

    def __init__(self):
        pass

    pass

stu=Student()

print(isinstance(stu,Student))# 结果为True

Funciones orientadas a objetos (encapsulación, herencia, polimorfismo)

Paquete

La encapsulación es un principio importante del método orientado a objetos, que consiste en combinar las propiedades y operaciones (o servicios) del objeto en un todo independiente y ocultar los detalles de implementación interna del objeto tanto como sea posible.

class Person:

    def __init__(self,name,age):
        self.__name=name
        self.__age=age
    
    @property
    def name(self):
        print('name的get方法')
        return self.__name
    
    @name.setter
    def name(self,name):
        print('name的set方法')
        self.__name=name

    @property
    def age(self):
        print('age的get方法')
        return self.__age

    @age.setter
    def age(self,age):
        print('age的set方法')
        self.__age=age

p=Person('张三',18)
print(p.name)
p.name='李四'
print(p.name)
print(p.age)
p.age=20
print(p.age)

resultado

heredar

Herencia significa que la subclase hereda las características y comportamientos de la clase principal, de modo que el objeto de la subclase (instancia) tiene el dominio de instancia y los métodos de la clase principal, o la subclase hereda métodos de la clase principal, de modo que la subclase tiene el mismo comportamiento que la clase padre. Por supuesto, si hay atributos privados (modificación privada) en la clase principal, la subclase no se puede heredar.
Python admite herencia múltiple

Herencia única

class Father:

    def __init__(self,name='暂未设置',age=28):
        '''
        构造函数
        '''
        self.__name=name
        self.__age=age
    
    def toString(self):
        print('name:{0}age:{1}'.format(self.__name,self.__age))


f=Father('张三',30)
f.toString()


class Children(Father):

    def __init__(self,name='暂未设置',age=18):
        '''
        子类需要显式的调用父类的构造函数
        \n不调用解释器不会去执行父类的构造函数
        '''
        self.__name=name
        self.__age=age
        Father.__init__(self)

c=Children()
c.toString()

Herencia múltiple

class a:
    def say(self):
        print('你好，我是a类说的第一句话')

class b:
    def hello(self):
        print('b说的话')
    
class c(a,b):
    pass

c=c()
c.hello()
c.say()

resultado

Polimorfismo

El polimorfismo es la capacidad de tener múltiples manifestaciones o formas diferentes del mismo comportamiento.

class Man:

    def eat(self):
        print('吃饭方法')
    pass

class Chinese(Man):

    def eat(self):
        print('中国人吃饭用叉子')
    pass

class English(Man):

    def eat(self):
        print('英国人吃饭用筷子')
        pass
    pass

class Indian(Man):

    def eat(self):
        print('印度人吃饭用手')
        pass
    pass

def runEat(man):
    if isinstance(man,Man):
        man.eat()
    else :
        print('非man')

runEat(Chinese())
runEat(English())
runEat(Indian())