Página de inicio del autor: Programming Compass Breve introducción
del autor : desarrollo de proyectos Java, desarrollo de diseños de graduación, organización de tecnología para entrevistas, intercambio Favoritos, me gusta , No se pierda, es bueno seguir al autor, obtenga del artículoel código fuente
Aprendizaje avanzado de Python
1. Clases y Objetos
1.1 Descripción general orientada a objetos
La abreviatura en inglés de Orientado a objetos es OO, que es una idea de diseño. Desde que se propuso el concepto de orientación a objetos en la década de 1960, se ha convertido en una idea de programación relativamente madura y gradualmente se ha convertido en el concepto actual de desarrollo de software. campo.
El objeto (Objeto) en orientación a objetos generalmente se refiere al objeto que existe en el mundo objetivo. Este objeto es único, y los objetos son diferentes y tienen sus propias características. Cada objeto tiene su propia ley de movimiento y estado interno. ; Objetos pueden vincularse e interactuar entre sí. Un objeto también puede ser algo abstracto. Los objetos generalmente se dividen en partes estáticas y partes dinámicas: la parte estática se refiere a algunos atributos del objeto en sí y la parte dinámica se refiere a algunas acciones realizadas por el objeto.
Una clase es un soporte para encapsular objetos y describe objetos definiendo atributos y métodos comunes. Por ejemplo, los seres humanos (Persona) tienen sus propios atributos como nombre, edad, altura, peso, etc., y también pueden comer, dormir, sentarse, caminar, etc., y usar clases para describirlos. Puedes usar clases para crear atributos y formas que son diferentes: el objeto específico, es decir, el individuo.
Tres características de la programación orientada a objetos: encapsulación, herencia y polimorfismo.
1.2 Definición y uso de clases.
En Python, las clases se definen usando la palabra clave class:
Class ClassName:
'''帮助信息'''
statement
Ejemplo: si no sabe cómo escribir el código al definir la clase, puede usar pass para establecer un código vacío (marcador de posición)
Class Person:
pass
Crea una instancia de la clase:
instancename = ClassName(parameterList)
Al definir una clase, generalmente se crea automáticamente un método '_init_()', que es equivalente al método de construcción en Java, y se ejecuta automáticamente cuando se crea un objeto de instancia. Debe contener un parámetro propio, que se utiliza para hacer referencia a sus propias propiedades y métodos, y también se pueden agregar otros parámetros. Cuando tiene solo un parámetro, cuando se usa la clase para crear instancias, no es necesario pasar el parámetro.
Ejemplo:
#定义类
class Geese:
'''大雁类'''
def __init__(self):
print("我是大雁类")
wildGoose = Geese()
En el método '_init_()', también se pueden personalizar algunos parámetros:
Ejemplo:
#定义类
class Geese:
'''大雁类'''
def __init__(self,beak,wing,claw):
print("我是大雁类,我有以下特征：")
print(beak)
print(wing)
print(claw)
beak = '喙的基部较高，长度和高度基本一致'
wing_1 = '翅膀长而尖'
claw_1 = '爪子是噗状的'
wildGoose = Geese(beak,wing_1,claw_1)
1.3 Crear miembros de la clase y acceder a ellos
Los miembros de una clase se componen principalmente de métodos de instancia y miembros de datos. Una vez que los miembros de la clase se crean en la clase, se puede acceder a ellos a través de la instancia de la clase.
1. Cree un método de instancia y acceda a él:
Un método de instancia es una función definida en una clase. Debe contener un parámetro propio y debe ser el primero. La sintaxis es la siguiente:
def functionname(self,parameterlist)
block
Una vez definido el método de instancia, se puede llamar por el nombre de la instancia:
instancename.functionname(parameterlist)
2. Cree miembros de datos y acceda a ellos:
Los miembros de datos son variables definidas en una clase, es decir, atributos. Según la ubicación de la definición, se divide en atributos de clase y atributos de instancia.
Los atributos de clase se refieren a los atributos definidos en la clase y fuera del cuerpo de la función. Todas las instancias pueden compartir y acceder a los atributos de clase. Se puede acceder por nombre de clase o nombre de instancia.
Ejemplo:
#定义类 类属性
class Geese:
'''大雁类'''
beak = '喙的基部较高，长度和高度基本一致'
wing = '翅膀长而尖'
claw = '爪子是噗状的'
def __init__(self):
print("我是大雁类,我有以下特征：")
print(Geese.beak)
print(Geese.wing)
print(Geese.claw)
wildGoose = Geese()
El atributo de instancia se refiere al atributo definido en el método de la clase, que solo actúa en la instancia actual. Solo se puede acceder a los atributos de instancia por nombre de instancia, no por nombre de clase.
Ejemplo:
#定义类 实例属性
class Geese:
'''大雁类'''
def __init__(self):
self.beak = '喙的基部较高，长度和高度基本一致'
self.wing = '翅膀长而尖'
self.claw = '爪子是噗状的'
print("我是大雁类,我有以下特征：")
print(self.beak)
print(self.wing)
print(self.claw)
wildGoose = Geese()
También se accede a los atributos de la instancia modificando el nombre de la instancia:
#定义类
class Geese:
'''大雁类'''
def __init__(self,beak,wing,claw):
self.neck = '脖子较长'
print(self.neck)
wildGoose = Geese()
wildGoose1 = Geese()
wildGoose1.neck = '脖子没有天鹅长'
print('wildGoose的脖子:',wildGoose.neck)
print('wildGoose1的脖子:',wildGoose1.neck)
1.4 Restricciones de acceso
Para garantizar que no se acceda externamente a los atributos y métodos definidos en la clase, Python proporciona _ foo con un guión bajo único, _ _ foo con un guión bajo doble y _ foo_ con subrayados al principio y al final para restringir el acceso. foo Un atributo o nombre de acceso para esta era.
_ foo _: indica la definición de acceso especial, como el método de inicialización _ _init _ _
_ foo: comenzar con un solo guión bajo significa miembros protegidos (protegidos) definidos, a los que solo se puede acceder a través de la clase y sus subclases. Pero no puede utilizar "desde la importación del módulo *" para importar.
Ejemplo:
#访问限制
class Swan:
'''天鹅类'''
_neck_swan = '天鹅的脖子很长' #定义保护类型属性
def __init__(self):
print("__init__():"+Swan._neck_swan) #在实例访问中访问私有属性
swan = Swan() #创建Swan类的实例
print("直接访问：",swan._neck_swan) # 保护属性可以通过实例名访问
_ _foo: los guiones bajos dobles representan miembros de tipo privado (privado). Solo se permite el acceso a los métodos de la clase, no a través de instancias. Pero se puede acceder a él a través de "nombre de instancia. nombre de clase_nombre de miembro".
Ejemplo:
#访问限制 私有属性
class Swan:
'''天鹅类'''
__neck_swan = '天鹅的脖子很长' #定义私有类型属性
def __init__(self):
print("__init__():"+Swan._neck_swan) #在实例访问中访问私有属性
swan = Swan() #创建Swan类的实例
print("加入类名：",swan._Swan__neck_swan) #私有属性，可以通过 “实例名.类名__xxx" 方式访问
print("直接访问：",swan._neck_swan) # 私有属性不可以通过实例名访问
1.5 Propiedades
En Python, puede convertir un método en una propiedad a través de @property para realizar la propiedad utilizada para el cálculo. Una vez que el método se convierte en un atributo, se puede acceder al método directamente a través del nombre del método sin agregar un par de paréntesis "()", lo que puede hacer que el código sea más conciso.
@property
def methodname(self):
block
* methodname :方法名
* self:必要参数，表示类的实例
* block: 方法体
Ejemplo:
#定义属性
class Rect:
def __init__(self,width,height):
self.width = width #矩形的宽
self.height = height #矩形的高
@property #将方法转换为属性
def area(self): #计算机矩形的面积的方法
return self.width*self.height #返回矩形面积
rect = Rect(800,600) #创建类的实例
print("面积为:",rect.area) #输出属性的值
En Python, de forma predeterminada, los atributos o instancias de la clase creada se pueden modificar fuera de la clase, si desea restringir que estén fuera del cuerpo de la clase.
Se puede modificar fuera de la clase y se puede configurar como privado, pero después de configurarlo como privado, su valor no se puede obtener fuera de la clase. Entonces, si desea crear una propiedad que se pueda leer pero no modificar, puede usar @property para implementar una propiedad de solo lectura.
Ejemplo:
#创建只读属性
class TVShow:
def __init__(self,show):
self.__show = show
@property #将方法转换为属性
def show(self): #定义show()方法
return self.__show #返回私有属性的值
tvshow = TVShow("正在播放 青春无悔") #创建类的实例
print("默认：",tvshow.show) #获取属性值
Pero si desea modificar el valor de show, se informará un error:
tvshow.show = '正在播放 大决战'
print("修改后：",tvshow.show)
Error:
AttributeError: can't set attribute
1.6 Herencia
La herencia puede lograr la reutilización del código y, al mismo tiempo, la relación entre clases se puede corregir mediante la herencia.
class ClassName(baseclasslist):
'''类的帮助信息''' #类文档字符串
statement #类体
* baseclasslist:用于指定要继承的基类，可以有多个，类名之间用 ，号分隔，如果不指定，将使用所有Python对象的根类object.
Reescritura de métodos: los miembros de la clase base serán heredados por la clase derivada. Cuando un método en la clase base no es completamente aplicable a la clase derivada, es necesario anular el método de la clase principal en la clase derivada.
Ejemplo:
#继承
class Fruit:
color = '绿色'
def harvest(self,color):
print("水果是:"+color+"的！")
print("水果已经收获.....")
print("水果原来是："+Fruit.color+"的！")
class Orange(Fruit):
color = "橙色"
def __init__(self):
print("\n 我是橘子")
def harvest(self,color):
print("橘子是"+color+"的！")
print("橘子已经收获....")
print("橘子原来是："+Fruit.color+"的！")
orange = Orange()
orange.harvest("黄色")
La llamada al método _ _init _ _ de la clase base debe realizarse mediante super():
#调用父类的__init__方法
class Fruit:
def __init__(self,color="绿色 "):
Fruit.color = color
def harvest(self):
print("水果原来是： "+Fruit.color+"的！")
class Apple(Fruit):
def __init__(self):
super().__init__()
print("我是苹果")
apple = Apple()
apple.harvest()