Prefacio
Python ha sido un lenguaje orientado a objetos desde el principio y, debido a esto, es fácil crear clases y objetos en Python. En este capítulo presentaremos en detalle la programación orientada a objetos en Python.
Si no ha estado expuesto a los lenguajes de programación orientados a objetos antes, es posible que primero deba comprender algunas características básicas de los lenguajes orientados a objetos y formar en su mente un concepto básico orientado a objetos, lo que le ayudará a aprender Python. más fácilmente Programación Orientada a Objetos.
A continuación, primero comprendamos brevemente algunas características básicas de la orientación a objetos.
Introducción a la tecnología orientada a objetos.
- Clase : se utiliza para describir una colección de objetos con las mismas propiedades y métodos. Define las propiedades y métodos comunes a cada objeto de la colección. Los objetos son instancias de clases.
- Método : Función definida en la clase.
- Variables de clase : las variables de clase son públicas en todo el objeto instanciado. Las variables de clase se definen en la clase y fuera del cuerpo de la función. Las variables de clase generalmente no se utilizan como variables de instancia.
- Miembros de datos : las variables de clase o variables de instancia se utilizan para manejar datos relacionados con la clase y sus objetos de instancia.
- Reescritura de métodos : si el método heredado de la clase principal no puede satisfacer las necesidades de la subclase, se puede reescribir. Este proceso se denomina anulación de método, también conocido como reescritura de métodos.
- Variables locales : las variables definidas en los métodos solo afectan la clase de la instancia actual.
- Variables de instancia : en la declaración de una clase, los atributos están representados por variables. Dichas variables se denominan variables de instancia. Una variable de instancia es una variable modificada con self.
- Herencia : una clase derivada hereda los campos y métodos de una clase base. La herencia también permite que un objeto de una clase derivada sea tratado como un objeto de clase base. Por ejemplo, existe un diseño de este tipo: un objeto de tipo Perro se deriva de la clase Animal, que simula la relación "es-un" (por ejemplo, Perro es un animal).
- Creación de instancias : crea una instancia de una clase, un objeto específico de la clase.
- Objeto : una instancia de una estructura de datos definida por una clase. Los objetos incluyen dos miembros de datos (variables de clase y variables de instancia) y métodos.
En comparación con otros lenguajes de programación, Python agrega mecanismos de clases sin agregar nueva sintaxis y semántica tanto como sea posible.
Las clases en Python proporcionan todas las funciones básicas de la programación orientada a objetos: el mecanismo de herencia de las clases permite múltiples clases base, las clases derivadas pueden anular cualquier método en la clase base y se pueden llamar métodos con el mismo nombre en la clase base.
Los objetos pueden contener cualquier cantidad y tipo de datos.
definición de clase
El formato de sintaxis es el siguiente:
class ClassName:
<statement-1>
.
.
.
<statement-N>
Una vez que se crea una instancia de una clase, se pueden usar sus propiedades. De hecho, después de crear una clase, se puede acceder a sus propiedades a través del nombre de la clase.
Ejemplo de código:
class MyClass:
"""一个简单的类实例"""
i = 12345
def f(self):
return 'hello world'
objeto
Los objetos admiten dos operaciones: referencia de propiedad y creación de instancias.
Las referencias de propiedades utilizan la misma sintaxis estándar que todas las referencias de propiedades en Python: obj.name.
Una vez creado un objeto de clase, todos los nombres en el espacio de nombres de la clase son nombres de atributos válidos. Entonces, si la definición de clase se ve así:
#!/usr/bin/python3
class MyClass:
"""一个简单的类实例"""
i = 12345
def f(self):
return 'hello world'
# 实例化类
x = MyClass()
# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())
Lo anterior crea una nueva instancia de clase y asigna el objeto a la variable local x, que es un objeto vacío.
El resultado de salida de ejecutar el programa anterior es:
El atributo i de la clase MyClass es: 12345
La salida del método f de la clase MyClass es: hola mundo
Las clases tienen un método especial ( constructor ) llamado _ init _() , que se llama automáticamente cuando se crea una instancia de la clase, así:
def __init__(self):
self.data = []
La clase define el método _ init _() y la operación de creación de instancias de la clase llamará automáticamente al método _ init _(). Cuando se crea una instancia de la clase MyClass de la siguiente manera , se llamará al método _init _() correspondiente:
x = MyClass()
Por supuesto, el método _ init _() puede tener parámetros, y los parámetros se pasan a la operación de creación de instancias de la clase a través de init (). Por ejemplo:
#!/usr/bin/python3
class Complex:
def __init__(self, realpart, imagpart):
self.r = realpart
self.i = imagpart
x = Complex(3.0, -4.5)
print(x.r, x.i) # 输出结果：3.0 -4.5
self representa una instancia de una clase, y
los métodos que no son de clase tienen solo una diferencia especial con las funciones ordinarias : deben tener un primer nombre de parámetro adicional, que por convención es self .
class Test:
def prt(self):
print(self)
print(self.__class__)
t = Test()
t.prt()
El resultado de la ejecución del ejemplo anterior es:
<_ principal _.Test objeto en 0x000001B55C75B610>
<clase '_ principal _.Test'>
A partir de los resultados de la ejecución, es obvio que self representa una instancia de la clase y la dirección del objeto actual, mientras que self.class apunta a la clase.
self no es una palabra clave de Python, si la reemplazamos con runoob, se puede ejecutar normalmente:
class Test:
def prt(tarzan):
print(tarzan)
print(tarzan.__class__)
t = Test()
t.prt()
El resultado de la ejecución del ejemplo anterior es:
<_ principal _.Test objeto en 0x000001702A38B650>
<clase '_ principal _.Test'>
métodos de clase
Dentro de una clase, use la palabra clave def para definir un método. A diferencia de las definiciones de funciones generales, los métodos de clase deben contener el parámetro self , que es el primer parámetro. Self representa una instancia de la clase.
#!/usr/bin/python3
#类定义
class people:
#定义基本属性
name = ''
age = 0
#定义私有属性,私有属性在类外部无法直接进行访问
__weight = 0
#定义构造方法
def __init__(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print("%s 说: 我 %d 岁,体重 %d 公斤。" %(self.name,self.age,self.__weight))
# 实例化类
p = people('tarzan',30,70)
p.speak()
El resultado de salida de ejecutar el programa anterior es:
tarzán dijo: tengo 30 años y peso 70 kg
heredar
Python también admite la herencia de clases. Si un lenguaje no admite la herencia, las clases no tienen sentido. La definición de la clase derivada es la siguiente:
class DerivedClassName(BaseClassName):
<statement-1>
.
.
.
<statement-N>
La subclase (DerivedClassName) heredará las propiedades y métodos de la clase principal (BaseClassName).
BaseClassName (el nombre de la clase base en la instancia) debe definirse en el mismo ámbito que la clase derivada. Además de las clases, también puedes usar expresiones, lo cual es útil cuando la clase base está definida en otro módulo:
class DerivedClassName(modname.BaseClassName):
Ejemplo de código
#!/usr/bin/python3
#类定义
class people:
#定义基本属性
name = ''
age = 0
#定义私有属性,私有属性在类外部无法直接进行访问
__weight = 0
#定义构造方法
def __init__(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print("%s 说: 我 %d 岁。" %(self.name,self.age))
#单继承示例
class student(people):
grade = ''
def __init__(self,n,a,w,g):
#调用父类的构函
people.__init__(self,n,a,w)
self.grade = g
#覆写父类的方法
def speak(self):
print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
s = student('ken',10,60,3)
s.speak()
El resultado de salida de ejecutar el programa anterior es:
Ken dijo: Tengo 10 años y estoy en tercer grado.
herencia múltiple
Python también tiene soporte limitado para múltiples formas de herencia. La definición de clase de herencia múltiple se parece al siguiente ejemplo:
class DerivedClassName(Base1, Base2, Base3):
<statement-1>
.
.
.
<statement-N>
- Debe prestar atención al orden de la clase principal entre paréntesis. Si hay el mismo nombre de método en la clase principal, pero no se especifica cuando se usa en la subclase, Python busca de izquierda a derecha. Es decir, cuando el método no se encuentra en la subclase, busca de izquierda a derecha si la clase principal contiene métodos.
Ejemplo de código
#!/usr/bin/python3
#类定义
class people:
#定义基本属性
name = ''
age = 0
#定义私有属性,私有属性在类外部无法直接进行访问
__weight = 0
#定义构造方法
def __init__(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print("%s 说: 我 %d 岁。" %(self.name,self.age))
#单继承示例
class student(people):
grade = ''
def __init__(self,n,a,w,g):
#调用父类的构函
people.__init__(self,n,a,w)
self.grade = g
#覆写父类的方法
def speak(self):
print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
#另一个类，多继承之前的准备
class speaker():
topic = ''
name = ''
def __init__(self,n,t):
self.name = n
self.topic = t
def speak(self):
print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))
#多继承
class sample(speaker,student):
a =''
def __init__(self,n,a,w,g,t):
student.__init__(self,n,a,w,g)
speaker.__init__(self,n,t)
test = sample("Tim",25,80,4,"Python")
test.speak() #方法名同，默认调用的是在括号中参数位置排前父类的方法
El resultado de salida de ejecutar el programa anterior es:
Mi nombre es Tim, soy orador y el tema de mi discurso es Python.
Anulación del método
Si la función del método de su clase principal no puede satisfacer sus necesidades, puede anular el método de su clase principal en la subclase. Los ejemplos son los siguientes:
#!/usr/bin/python3
class Parent: # 定义父类
def myMethod(self):
print ('调用父类方法')
class Child(Parent): # 定义子类
def myMethod(self):
print ('调用子类方法')
c = Child() # 子类实例
c.myMethod() # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法
- La función super() es un método utilizado para llamar a la clase principal (superclase).
El resultado de salida de ejecutar el programa anterior es:
Llamar al método de la subclase
Llamar al método de la clase principal
Si necesita el constructor de la clase principal en una subclase, debe llamar explícitamente al constructor de la clase principal o no anular el constructor de la clase principal.
Las subclases no anulan _ init _. Al crear una instancia de una subclase, se llama automáticamente a _ init _ definido por la clase principal.
class Father(object):
def __init__(self, name):
self.name=name
print ( "name: %s" %( self.name) )
def getName(self):
return 'Father ' + self.name
class Son(Father):
def getName(self):
return 'Son '+self.name
if __name__=='__main__':
son=Son('runoob')
print ( son.getName() )
La salida es:
nombre: runoob
Hijo runoob
Si se anula _ init _ y se crea una instancia de la subclase, no se llamará al _ init _ definido por la clase principal. El formato de sintaxis es el siguiente:
class Father(object):
def __init__(self, name):
self.name=name
print ( "name: %s" %( self.name) )
def getName(self):
return 'Father ' + self.name
class Son(Father):
def __init__(self, name):
print ( "hi" )
self.name = name
def getName(self):
return 'Son '+self.name
if __name__=='__main__':
son=Son('runoob')
print ( son.getName() )
La salida es:
hola
hijo runoob
Si anula _init_ y desea heredar el método constructor de la clase principal, puede utilizar la palabra clave super :
super(子类，self).__init__(参数1，参数2，....)
También existe una forma clásica de escribir:
父类名称.__init__(self,参数1，参数2，...)
Ejemplo de código
class Father(object):
def __init__(self, name):
self.name=name
print ( "name: %s" %( self.name))
def getName(self):
return 'Father ' + self.name
class Son(Father):
def __init__(self, name):
super(Son, self).__init__(name)
print ("hi")
self.name = name
def getName(self):
return 'Son '+self.name
if __name__=='__main__':
son=Son('tarzan')
print ( son.getName() )
La salida es:
nombre: tarzán
hola
hijo tarzán
Propiedades y métodos de clase.
Propiedades privadas de clase
__private_attrs: comienza con dos guiones bajos, declara que el atributo es privado y no se puede usar ni acceder directamente fuera de la clase. Cuando se usa self.__private_attrs en un método dentro de una clase.
métodos de clase
Dentro de una clase, use la palabra clave def para definir un método. A diferencia de las definiciones de funciones generales, los métodos de clase deben contener el parámetro self, que es el primer parámetro. Self representa una instancia de la clase.
El nombre self no es fijo, también puedes usarlo , pero es mejor usar self según la convención .
método privado de clase
__private_method: comenzando con dos guiones bajos, el método se declara como un método privado y solo se puede llamar dentro de la clase, no fuera de la clase. self.__private_methods.
Ejemplos de propiedades privadas de la clase son los siguientes:
#!/usr/bin/python3
class JustCounter:
__secretCount = 0 # 私有变量
publicCount = 0 # 公开变量
def count(self):
self.__secretCount += 1
self.publicCount += 1
print (self.__secretCount)
counter = JustCounter()
counter.count()
counter.count()
print (counter.publicCount)
print (counter.__secretCount) # 报错，实例不能访问私有变量
El resultado de salida de ejecutar el programa anterior es:
1
2
2
Rastreo (última llamada más reciente):
Archivo “C:\Users\Lenovo\Desktop\test.py”, línea 14, en
formato impreso (counter.__secretCount) # Error, la instancia no puede acceder a variables privadas
^^^^^ ^^^^^^^^^^^^^^^^
AttributeError: el objeto 'JustCounter' no tiene el atributo '__secretCount'
Ejemplos de métodos privados de la clase son los siguientes:
#!/usr/bin/python3
class Site:
def __init__(self, name, url):
self.name = name # public
self.__url = url # private
def who(self):
print('name : ', self.name)
print('url : ', self.__url)
def __foo(self): # 私有方法
print('这是私有方法')
def foo(self): # 公共方法
print('这是公共方法')
self.__foo()
x = Site('洛阳泰山博客', 'https://tarzan.blog.csdn.net')
x.who() # 正常输出
x.foo() # 正常输出
x.__foo() # 报错
El resultado de ejecución del código anterior:
name : 洛阳泰山博客
url : https://tarzan.blog.csdn.net
这是公共方法
这是私有方法
Traceback (most recent call last):
File "C:\Users\Lenovo\Desktop\test.py", line 22, in <module>
x.__foo() # 报错
^^^^^^^
AttributeError: 'Site' object has no attribute '__foo'
- Motivo de la excepción El método externo no puede llamar al método privado.
Métodos privados de clase:
_ init _: Constructor, llamado al generar un objeto
_ del _: Destructor, usado al liberar un objeto
_ repr _: Imprimir, convertir
_ setitem _: Asignar valor según el índice
_ getitem _: Obtener valor según el índice
_ len _ : Obtener longitud
_ cmp _: Operación de comparación
_ llamada _: Llamada de función
_ agregar _: Operación de suma
_ sub _: Operación de resta
_ mul _ : Operación de multiplicación
_ truediv _: Operación de división
_ mod _: Operación de resto
_ pow _: Multiplicación cuadrado
Sobrecarga del operador
Python también admite la sobrecarga de operadores. Podemos sobrecargar métodos propietarios de clases. Los ejemplos son los siguientes:
#!/usr/bin/python3
class Vector:
def __init__(self, a, b):
self.a = a
self.b = b
def __str__(self):
return 'Vector (%d, %d)' % (self.a, self.b)
def __add__(self,other):
return Vector(self.a + other.a, self.b + other.b)
v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)
El resultado de ejecutar el código anterior es el siguiente:
Vector(7,8)