[Python Basics 3] Tutorial súper detallado para amigos principiantes

prefacio

Artículos anteriores:

[Conceptos básicos de Python 1] Tutorial súper detallado para amigos principiantes

[Python Basics 2] Tutorial súper detallado para amigos principiantes

7. Programación orientada a objetos

Todo es un objeto, y Python ciertamente admite la programación orientada a objetos. Las clases y los objetos son los dos aspectos principales de la programación orientada a objetos, una clase crea un nuevo objeto y un objeto es una instancia de esta clase.

Los objetos pueden usar variables de clase, y las variables que pertenecen a objetos o clases se denominan campos; los objetos también pueden usar funciones que pertenecen a clases, y tales funciones se denominan métodos de clase; los campos y métodos pueden denominarse colectivamente atributos de clase.

Los dominios son de dos tipos.

• Perteneciente a la instancia
• pertenece a la clase misma

Se denominan variables de instancia y variables de clase respectivamente.

Las clases se crean utilizando palabras clave classy los campos y métodos de la clase se enumeran en un bloque sangrado.

El método de la clase debe tener un primer parámetro adicional, pero a este parámetro no se le asigna un valor cuando se llama. Esta variable especial se refiere al objeto en sí. Por convención, su nombre es self, similar a esto en Java.

Los siguientes dos métodos especiales en la clase necesitan atención:

• __init__Método: Llame a este método cuando se crea un objeto de la clase, es equivalente al constructor en C++, es decir, cuando se llama a esta clase, entonces se ejecutará el método __init__.

• __del__Método: Este método se llama cuando se destruye el objeto de la clase, es equivalente al destructor en C++. Cuando se usa del para eliminar un objeto, también se llama al método __del__, y __del__ se llama en último lugar.

Todos los miembros de la clase (incluidos los miembros de datos) en Python son públicos. No hay una clase privada en Java, es decir, todos tienen una clase que llama. Aunque la escritura se vuelve muy simple,
todos pueden asignar acceso a los recursos a voluntad. En el proyecto es de hecho algo malo.

Pero la clase de Python tiene variables privadas y métodos privados. Esta es una excepción. Si el miembro de datos utilizado tiene el prefijo con un guión bajo doble, es una variable privada.

Crea una instancia de esta clase y no puede acceder a ella. Esto es lo que mucha gente ignora.

por ejemplo:

class public():
    _name = 'protected类型的变量'
    __info = '私有类型的变量'
    def _f(self):
        print("这是一个protected类型的方法")
    def __f2(self):
        print('这是一个私有类型的方法')
    def get(self):
        return(self.__info)
pub = public()
# 先打印可以访问的
print(pub._name)
pub._f()
####结果如下####
protected类型的变量
这是一个protected类型的方法


# 打印下类 私有变量和私有方法
print(pub.__info)
报错：'public' object has no attribute '__info'
pub._f2()
报错：pub._f2()

Pero las propiedades y los métodos privados se pueden llamar en la misma clase.

pub.get()
#######
'私有类型的变量'

Lo anterior es desconocido para muchas personas. A continuación, permítanme declarar una clase Person

   
class Person():
    Count = 0
    def __init__(self, name, age):
        Person.Count += 1
        self.name = name
        self.__age = age
    
p = Person("Runsen", 20)

print(p.Count)

# 1 说明我实例化，这个__init__方法就要执行


print(p.name) #Runsen
print (p.__age) 
#AttributeError: Person instance has no attribute '__age'
#私有变量访问不了，报错

8. Herencia

Programación orientada a objetos (POO), nombre completo en inglés: Programación orientada a objetos, una de las funciones principales de la programación orientada a objetos es la "herencia". La herencia se refiere a la capacidad de usar toda la funcionalidad de una clase existente y ampliar esa funcionalidad sin volver a escribir la clase original.

La herencia, de hecho, se entiende de esta manera, es decir, escribí una clase de padre y una clase de hijo. El padre tiene dinero, pero el hijo no tiene dinero, por lo que el hijo decide heredar al padre y llamar al dinero del padre ( variables y métodos de la clase padre).

Heredar una clase y básicamente usar los siguientes cinco métodos.

8.1 Llame directamente al método de atributo de la clase padre;

El padre tiene dinero, pero el hijo no tiene dinero, entonces el hijo usa el dinero del padre.

class Father():
    def __init__(self):
        self.money= 1000 
    def action(self):
        print('调用父类的方法')
 
class Son(Father):
    pass
 
son=Son()     # 子类Son 继承父类Father的所有属性和方法
son.action()  # 调用父类属性
输出：调用父类的方法
son.money     # 调用父类属性
输出：1000

8.2 Llamar a la fuerza al método de propiedad privada de la clase padre;

Papá dijo, tu hijo siempre usa mi dinero, así que decidí esconder mi dinero. Hijo, intente super()tomar su dinero privado, pero aquí debe prestar atención super()para forzar la llamada del método de atributo privado de la clase principal, que es anular el método. Las variables privadas no pueden ser heredadas por la cena, y no puede acceder a las variables de el método de atributo privado en la clase principal, es decir, el hijo no puede obtener el dinero de su casa privada.

class Father():
    __money  = 1000 #私有变量是继承不了
    
    def __action(self):  # 父类的私有方法
        money = 1000
        print('调用父类的方法')
 
class Son(Father):
        
    def action(self):
        super()._Father__action()
        print(money) 
        
son=Son()
son.action() 

调用父类的方法
name 'money' is not defined

8.3 Reescribir el método de atributo de clase principal;

De repente, el hijo era rico, por lo que decidió no usar el dinero de su padre, sino su propio dinero, y decidió reescribir el método de propiedad de la clase padre.

class Father():
    def __init__(self):
        self.money = 0
    
    def action(self):
        print('调用父类的方法')
 
class Son(Father):
    def __init__(self):
        self.money = 1000
      
    def action(self):
        print('子类重写父类的方法')
 
son=Son()     # 子类Son继承父类Father的所有属性和方法
son.action()  # 子类Son调用自身的action方法而不是父类的action方法
son.money     # 自己的1000

8.4 Llamar al método __init__ de la clase padre

Si el padre pone el dinero __init__, es posible que el hijo obtenga el dinero del padre, no es una variable privada, no es dinero privado, por supuesto que puede obtenerlo

A ver si podemos conseguirlo si no usamos super.

class Father():
    def __init__(self):
        self.money = 1000
 
class Son(Father):
    def __init__(self):
        pass
    
son=Son()
print(son.money)

# 报错：'Son' object has no attribute 'money'

Ni siquiera usar el súper es como tomar dinero, nos subestimas demasiado a tu padre ya mí.

class Father():
    def __init__(self):
        self.money = 1000
 
class Son(Father):
    def __init__(self):
        super().__init__()
        #也可以用 Father.__init__(self)  这里面的self一定要加上(上面两个相同)
        
        
son=Son()
print(son.money) 

1000

8.5 Heredar los parámetros en el proceso de inicialización de la clase padre

A veces, papá necesita ganar y gastar dinero, que son los parámetros en nuestro proceso de inicialización. El hijo tiene mucha curiosidad y decide ver cuánto dinero necesita papá en su bolsillo.

Hemos escrito ganar_dinero y gastar_dinero aquí primero

class Father():
    def __init__(self):
        self.earn_money=1000
        self.spend_money= -500
 
class Son(Father):
    def __init__(self):
        super().__init__()
        #也可以用 Father.__init__(self)  这里面的self一定要加上
        
    def add(self):
        return self.earn_money+self.spend_money
        
        
son=Son()
print(son.add())

500

El hijo descubrió que su padre no tenía suficiente dinero, por lo que en secreto tomó algo de dinero.

class Father():
    def __init__(self,a,b):
        self.earn_money = a
        self.spend_money= b
    def add(self):
        return self.a + self.b
 
#调用父类初始化参数a,b并增加额外参数c
class Son(Father):
    def __init__(self,a,b,c=1000):  # c固定值
        Father.__init__(self,a,b)  
        self.son_money = c
        
    def add(self):
        return self.earn_money+self.spend_money + self.son_money
        
   
        
son=Son(1000,-500)   # 所以c可以不用显示表达出来
print(son.add())     # 调用子类add函数

1500

Lo anterior cubre básicamente la herencia de las clases de Python, el contenido básico de llamar a los atributos y métodos de la clase principal, y puede escribir algunos casos usted mismo para profundizar su comprensión.

9. Entrada/salida

La interacción entre el programa y el usuario necesita usar entrada/salida, incluyendo principalmente la consola y los archivos; para la consola, se puede usar entrada e impresión. input(xxx) ingresa xxx,
luego lee la entrada del usuario y regresa.

In [1]: input()
1
Out[1]: '1'

10. Entrada/salida de archivos

Puede usar la clase de archivo para abrir un archivo y usar la lectura, la línea de lectura y la escritura del archivo para leer y escribir el archivo de manera adecuada. La capacidad de leer y escribir archivos depende del modo utilizado al abrir el archivo,
modo común

• modo de lectura ("r")
• modo de escritura ("w")
• agregar modo ("a")

Después de la operación del archivo, debe llamar al método de cierre para cerrar el archivo. Si usa con abierto, no necesita slose.

Y r+, w+, a+

• r: solo significa leer
• r+: puede leer y escribir
• w: solo significa escribir
• w+: lectura y escritura

Sin embargo, la diferencia entre r+ y w+ es que no borrará el contenido original en txt. La siguiente es su comparación. De todos modos, trate de usar a+ tanto como sea posible, y básicamente no hay informes erróneos.

describir	r+	en+	un+
archivo cuando el archivo actual no existe	Lanzar una excepción	crear un archivo	crear un archivo
Contenido del archivo original después de abrir	reserva	vacío	reserva
posición inicial	0	0	fin del documento
escribir ubicación	marcar ubicación	marcar ubicación	Saltar al final del archivo por defecto al escribir

Añade un ejemplo:

test = '''\
This is a program about file I/O.
Author: Runsen
Date: 2020/3/31
'''
f = open("test.txt", "w") 
f.write(test) 
f.close() 

f = open("test.txt") #默认r
while True:
    line = f.readline()
    if len(line) == 0:  
        break
    print(line)
f.close()

######
This is a program about file I/O.

Author: Runsen

Date: 2020/3/31

11. Almacenamiento

Memoria, no debes saber. Python proporciona un módulo estándar llamado pickle, que puede almacenar cualquier objeto python en un archivo y luego sacarlo por completo, esto se llama objeto de almacenamiento persistente, hay otro módulo llamado cPickle, su función y Pickle es exactamente la misma, excepto que está escrito en C y es más rápido que pickle (alrededor de 1000 veces más rápido).

import pickle

datafile = "data.data"

mylist = ["Runsen", "is", "20"]

f = open("test.txt", "wb+")
pickle.dump(mylist, f)
f.close()

del mylist

f = open(datafile,'rb+')
mylist = pickle.load(f)

print(mylist)
#["Runsen", "is", "20"]

12. Anormal

Las excepciones ocurren cuando ciertas condiciones inusuales ocurren en un programa.

El procesamiento está disponible en python try ... except .

try:
    print (1/0)
except ZeroDivisionError as e:
    print(e)
except:
    print( "error or exception occurred.")

#integer division or modulo by zero

Por fin

Baozi, que acaba de empezar a ponerse en contacto con Python, puede enviarme un mensaje privado si no entiende nada.

¡También he preparado toneladas de tutoriales en video gratuitos, libros electrónicos en PDF y código fuente! ¡Solo tome la tarjeta de presentación al final del artículo!