1.OOP (programación orientada a objetos)

pensamiento:
- Resolver problemas de ingeniería con pensamiento modular
- Orientado a procesos frente a orientado a objetos
- De orientado a procesos a orientado a objetos
- Por ejemplo, quiero abrir una escuela:
  - conferenciante
  - director
  - estudiante
  - Salón de clases
  - 。。。。。。
Nombres comunes
- OO: Orientado a objetos
- OOA: análisis
- OOD: Diseño
- POO: Programación
- OOI: Implementación
- OOA -> OOD -> EOI
Clase vs objeto (las dos son relaciones de atribución, pero no relaciones de composición)
- Clase: Resumen, describiendo una colección, enfocándose en los puntos en común (clase de estudiantes)
- Objeto: Concreto, que describe al individuo (Sr. Zhang)
El contenido de la clase:
- Acción, función
- Atributos, variables
Definir la clase: palabra clave de clase
Denominación de clase:
- Siga la gran joroba (la primera letra de cada palabra está en mayúscula)
- Poner en mayúscula la primera letra

# 定义学生类，和几个学生

class Student():
    # 此处定义一个空类
    # pass是关键字，表示占位用的，无意义(养成好习惯)
    pass

# 定义一个对象
zhangsan = Student()

# 定义时，全体缩进
class PythonStudent():
    name = "Nobody"
    age = 20
    course = "Python"
    '''
    定义类中的函数，一般要有self关键字
    其余跟普通函数基本相同
    
    '''
    
    def giveMoney(self):
        print("show me the money")
        return None
    
lisi = PythonStudent()
print(lisi.name)
print(lisi.age)
print(lisi.course)

Nadie
20
Python

2. Atributos de la clase

# 类的例子
# 注意类的定义
class Student():
    # name,age是类的变量
    name = "amy"
    age = 20
    
    def sayHi(self):
        print("类的属性")
        return None
    
    
    def sayHello(koko):
        print("将self替换为koko")
        return None

# 实例化
lisi = Student()

print(lisi)

2.1 yo

self puede ser reemplazado por otro nombre
yo no es una palabra clave
El rol se refiere a sí mismo

# self举例

# 实例调用函

honghong = Student() # 实例化yaoyao

# 让honghong跟我打招呼
# honghong调用sayHi没有输入参数
# 因为迷人实例作为第一个传入的参数，即honghong代替self
honghong.sayHi()

# 错误的案例:
# a = "你好"
# honghong.sayHi(a)

Atributos de clase

#这个案例说明self的名称可以更改，实际上self为形参
honghong.sayHello()

Reemplazar a uno mismo con koko

2.2 El problema del alcance de la variable de clase

Variables de clase: variables pertenecientes a la propia clase
Variables de instancia: variables que pertenecen a la instancia
Un resumen de los siguientes dos casos:
- Después de definir las propiedades de la instancia, al acceder a las propiedades de la instancia, se da prioridad al acceso a las propiedades de la propia instancia; si no, se accede a las propiedades de la clase.

# 案例1：

# 注意类的定义
class Student():
    
    # name,age是类的变量
    name = "amy_77"
    age = 20
    
    def sayHi(self):
        print("My Name is {}, i am {} years old".format(self.name,self.age))
        self.age = 21
        self.name = "NoName"
        return None

# 此案例说明，实例变量可以借用类的变量
qianqian = Student()
qianqian.sayHi()

Mi nombre es Amy_77, tengo 20 años

# 案例2：

# 注意类的定义
class Student2():
    
    # name,age是类的变量
    name = "amy_77"
    age = 20
    
    def sayHi(self, n, a ):  # 实例变量,给self定义自己的变量name和age
        self.name = n
        self.age = a
        
        print("My Name is {}, i am {} years old".format(self.name,self.age))
        return None

# 此案例说明，实例变量可以借用类的变量
qianqian = Student2()

# 注意观察下面语句打开和关闭后的区别
# qianqian.sayHi("yuanyuan", 30)

print("My Name is {}, i am {} years old".format(Student2.name,Student2.age))
print("My Name is {}, i am {} years old".format(yuanyuan.name,yuanyuan.age))

#若果访问实例的属性没有定义，则自动访问类的属性
# 如果类也没有定义，则报错

Mi nombre es Amy_77, tengo 20 años
Mi nombre es Amy_77, tengo 20 años

2.3 Acceso a las propiedades de la clase

Si fuerza el acceso a los atributos de la clase en la clase, debe usar __class__ (dos guiones bajos antes y después)
Método de clase:
- Al definir el método de la clase, no hay un parámetro propio
- Solo el contenido de la clase está permitido en el método de la clase.
- Dos metodos
  - Nombre de la clase
  - __ clase __ (dos guiones bajos antes y después)

class Student3():
    
    # name,age是类的变量
    name = "amy_77"
    age = 20
    
    def sayHi(self):
        print("My Name is {}, i am {} years old".format(self.name,self.age))
        return None
    
    
    # SOS是类的方法
    def SOS():
        # 类方法中不允许访问实例的任何内容
        #print("My Name is {}, i am {} years old".format(self.name,self.age))
        
        # 如果访问想要类的内容，有下面两种方法：
        print("My Name is {}, i am {} years old".format(Student3.name,__class__.age))
        return None

# 体验类的方法
s = Student3()
s.sayHi()

# 调用类方法的例子
Student3.SOS()
# SOS() takes 0 positional arguments but 1 was given
# SOS（）接受0个位置参数，但给出了1个

Mi nombre es Amy_77, tengo 20 años
Mi nombre es Amy_77, tengo 20 años

2.4 Constructor

Cuando se crea una instancia de la clase, se realiza un trabajo de inicialización básico
Use nombres y palabras especiales
- Ejecutado automáticamente en la instanciación
- ¿Es la "primera" función que se ejecutará en la instanciación

class Student4():
    name = "Everybody"
    age = 0
    
    # 构造函数名称固定，写法相对固定
    def __init__(self):
        print("我是一个构造函数")


qianqian = Student4()
print("*******************")
print(qianqian.name)
print(qianqian.age)

Soy un constructor

Todo el mundo
0

3. Tres características de la orientación a objetos

heredar
Encapsulamiento
Polimorfismo

3.1 Herencia (Python no repite la rueda)

La palabra clase puede usar el contenido o comportamiento definido por la clase principal, etc.
Implementación de herencia:
- Clase padre, clase base, superclase: clase heredada, clase base, superclase
- Subclase, una clase con comportamiento heredado
- Todas las clases deben tener una clase para padres
- De lo contrario, el valor predeterminado es la palabra clase de objeto.

# 所有类必须有父类
# 默认为object
class Person1():
    pass

class Person2(object):
    pass

class Person():
    name = "NoName"
    age = 0
    
# 父类写在类定义的时候的括号里
class Teacher(Person):
    pass

t = Teacher()
print(t.name)

Sin nombre

class Bird():
    fly = "Yes,I can"
    
    def flying(self):
        print("飞呀飞呀")
        
class BirdMan(Person, Bird):
    pass

bm = BirdMan()
bm.flying()
print(bm.name

Volar Volar No
Nombre

3.2 issubclass detecta si es una subclase

Puede usarse para detectar la relación padre-hijo de dos clases

# 利用刚才定义的Bird，BirdMan，Person，Teacher，检测父子关系

print(issubclass(BirdMan, Bird))
print(issubclass(BirdMan, Person))
print(issubclass(BirdMan, Teacher))

# help(issubclass)

Verdadero
Falso
Falso

4. Constructor

Una función llamada cuando se crea una instancia de la función
Llamada automática
Afirmar:
- El primer parámetro debe estar presente, generalmente recomendado como auto
El tiempo de llamada del constructor: generalmente se considera que se llama por primera vez en el momento de la instanciación.
Generalmente, no se llama manualmente, se llama automáticamente cuando se crea una instancia y los parámetros deben escribirse entre corchetes después del nombre de la clase.

class Bird():
    def __init__(self):
        print("我被调用了")
        return None
    
# 此时被调用构造函数
b = Bird()

Fui llamado

# 构造函数2

class Person():
    def __init__(self, name, age):
        print(name, age)
        
p = Person("amy", 21)

amy 21

4.1 Herencia del constructor

Herencia predeterminada del constructor
Una vez que la subclase define el constructor, el constructor de la clase padre ya no se llama automáticamente

# 构造函数默认继承

class Person():
    def __init__(self, name, age):
        print("Person = ({}, {})".format(name, age))
        
        
# Teacher自动继承上面的构造函数
class Teacher(Person):
    pass

t = Teacher("amy", 21)

t = Teacher()# 此代码报错

Persona = (amy, 21)

Notas del estudio de Python cuatro: programación orientada a objetos (OOP)