En pocas palabras, un archivo fuente de Python (* .py) es un módulo.
Nuestro primer módulo de Python.
Luego, usamos un editor de texto (por ejemplo, el Código VS descrito anteriormente) para crear un archivo llamado my_first_module.py como el primer módulo que escribimos:
#!/usr/bin/env python3
# coding:utf-8
# Author: veelion
# file name: my_first_module.py
'''My First Module'''
MY_NAME = 'My_First_Module'
def my_print(a):
print(MY_NAME, ' print', a)
def my_add(a, b):
return a+b
Nuestro primer módulo de Python tiene una variable global: MY_NAME , dos funciones: my_print() y my_add() . Luego ejecutamos el ipython del intérprete de Python El directorio donde se encuentra este archivo. :
In [1]: import my_first_module
In [2]: my_first_module?
Type: module
String form: <module 'my_first_module' from '/home/veelion/p2/tutorial/md_Python/codes/my_first_module.py'>
File: ~/p2/tutorial/md_Python/codes/my_first_module.py
Docstring: My First Module
In [3]: my_first_module.MY_NAME
Out[3]: 'My_First_Module'
In [4]: my_first_module.my_add(2, 3)
Out[4]: 5
In [5]: my_first_module.my_print('learnPython')
My_First_Module print learnPython
El módulo de importación usa import , y el nombre del módulo es el nombre de archivo my_first_module.py eliminar el nombre del sufijo de archivo .py . Del uso de ipython anterior, podemos ver que se pueden usar las funciones y variables en el módulo.
Nota: El nombre de archivo del módulo Python solo puede ser letras, números y guiones bajos. No puede haber otros símbolos como -,+ etc. De lo contrario, la importación informará de un error. El motivo es muy simple. Por ejemplo, el símbolo - se confundirá con el signo menos en Python.
Cambie el nombre del módulo anterior a my-first-module.py e import para verlo:
In [6]: import my-first-module
File "<ipython-input-6-a8306ca40c5e>", line 1
import my-first-module
^
SyntaxError: invalid syntax
Dos o tres cosas sobre el módulo de Python
(1) Un módulo puede contener declaraciones globales ejecutables. Estas instrucciones deben utilizarse para inicializar el módulo, solo se ejecutan la primera vez que se import .Tomemos un ejemplo y creamos dos módulos que contienen solo una print :
# m1.py
print('m1 is imported')
# m2.py
import m1
print('m2 is imported')
Importe los dos módulos m1 y m2 en main.py :
import m1
import m2
import m1
print('I am main.py')
Aquí m1 se introduce explícitamente dos veces, y una vez más se importa con m2negativo, un total de tres veces, luego ¿ m1 is imported imprimirá 3 veces? Intentemos ejecutar este script: python main.py Adivina cual es el resultado de la carrera?
m1 is imported
m2 is imported
I am main.py
El resultado solo se imprime una vez. Esto es lo que es solo cuando se import primera import . Vuelva a intentar main.py los dos import m1 main.py ¿Cuál es el resultado de import m2 solo import m2 ?
(2) Cada módulo tiene su propia tabla de símbolos privada, que se utiliza como una tabla de símbolos global por todas las funciones en el módulo, es decir, cada módulo tiene su propio espacio de nombres. Por lo tanto, el módulo puede usar variables globales (si es necesario) sin preocuparse por los conflictos con las variables globales del usuario del módulo. El uso por parte del usuario de variables globales en el módulo también es muy simple: modname.itemname .
Por ejemplo, el MY_NAME en el módulo my_first_module se usa como my_first_module.MY_NAME , y en su propio script también puede nombrar la variable global de MY_NAME sin entrar en conflicto con my_first_module .
(3) El módulo puede import otros módulos. La importación de la instrucción de importmódulo no tiene que estar al principio del script y se puede importar cuando sea necesario en otra parte del código. Por supuesto, importar desde el principio es la forma más clara y estandarizada.
Varias formas de importar módulo.
Hay muchas formas de usar la import . El método anterior de import module_name es el más usado y también es el uso recomendado por la especificación del código. Hay otras formas de ser gramaticalmente:
(1) Importar parte con "from":
In [1]: from my_first_module import my_add
In [2]: my_add(1,3)
Out[2]: 4
In [3]: my_print('hi')
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-3-b42bb20df9e4> in <module>
----> 1 my_print('hi')
NameError: name 'my_print' is not defined
In [4]: my_first_module.my_add(1,2)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-4-df5ce230b443> in <module>
----> 1 my_first_module.my_add(1,2)
NameError: name 'my_first_module' is not defined
Al usar from modname import xxx , solo my_add y llamar a my_print error. Además, el nombre del módulo my_first_module tampoco está definido, es decir, no se ha importado.
(2) Importe la parte con "de" y cambie su nombre
Igual que (1), excepto que el nombre importado tiene un alias y se usa el alias:
from my_first_module import my_add as myadd
(3) Importar todos con "from"
In [1]: from my_first_module import *
In [2]: my_add(1,2)
Out[2]: 3
In [3]: my_print('learnPython')
My_First_Module print learnPython
In [4]: MY_NAME
Out[4]: 'My_First_Module'
Este enfoque parece simple, y el prefijo del nombre del módulo my_first_module se omite al escribir el código. Sin embargo, esta omisión trae grandes peligros ocultos y limita nuestra propia denominación. Si nos nombramos a nosotros mismos como el nombre en el módulo, se sobrescribirá el nombre dentro del módulo.
Este método de importación está estrictamente prohibido por las especificaciones del código.
(4) Renombrar el módulo Si el nombre del módulo es muy largo, podemos darle un breve alias, por lo que escribir el código será más sencillo:
In [1]: import my_first_module as mfm
In [2]: mfm.my_add(1,2)
Out[2]: 3
In [3]: mfm.my_print('learnPython')
My_First_Module print learnPython
In [4]: mfm.MY_NAME
Out[4]: 'My_First_Module'
En realidad, es lo mismo que import my_first_module , excepto que el nombre utilizado se cambia a mfm . El alias del módulo se puede elegir arbitrariamente, siempre que se distinga de otros nombres.
(5) Recarga de módulos Escribimos un módulo, que puede ser verificado por un intérprete de Python (como ipython), así que ejecutamos el intérprete de Python, importamos el módulo y encontramos que una función de módulo tiene un error, se modifica en el editor. Esta función guarda el archivo del módulo. Continúe para verificar la función con el error en el intérprete recién abierto, y se encontró que la modificación no tuvo efecto, ¡no tuvo efecto! ! !
Por que Por eficiencia, los módulos importados por cada intérprete se importan solo una vez. Por lo tanto, si modifica el módulo a mitad de camino, el intérprete volverá a ingresar y volverá a importar el módulo para que los cambios surtan efecto. Si vuelve a importar el módulo sin salir del intérprete, no importa cuántas veces ejecute el nombre de import modname es válido, porque el intérprete no ha importado el módulo una vez que se ha importado. El intérprete es perezoso, no puedes ser perezoso.
Alternativamente, puede volver a importar usando importlib.reload() sin reiniciar el intérprete.
Ejecutar el módulo de Python como un script
Cualquier archivo de Python se puede ejecutar de esta manera:
python3 file.py
El módulo Python de un archivo, por supuesto, también se puede ejecutar de esta manera. Un archivo Python, delante de la definición de la función, después de ejecutar la definición, tenemos que escribir la declaración de llamada, inicialmente puede ser así:
# Author: veelion
# file: mylib.py
def add(a, b):
return a+b
print(add(2, 3))
Ejecútelo a través de python mylib.py y obtendrá los resultados.
Parece que todo es normal ahora, ¿tienes algún problema?
Mirando hacia atrás en el primero (3) del módulo anterior dos o tres cosas , si este archivo es importado como un módulo por otros archivos, ¿también está ejecutando una declaración de impresión? Esta declaración de impresión es a menudo el código que probamos para verificar la función add() , que forma parte de la fase de prueba y no es necesaria cuando se entrega a otros como un módulo. Entonces, ¿qué debo hacer?
El atributo __name__ se puede usar para limitar el funcionamiento de la instrucción print(add(2, 3)) . Cuando el archivo se ejecuta como un script, su atributo __name__ es __main__ , y cuando se __name__ el módulo, su atributo __name__ es el nombre del módulo.
Primero mire el __name__ cuando se __name__ el módulo:
In [24]: import mylib
5
In [25]: mylib.__name__
Out[25]: 'mylib'
Podemos ver que después de import mylib , import mylib 5 , que es la declaración print(add(2, 3)) .
Luego, modificamos el archivo mylib.py y modificamos la declaración de prueba:
# Author: veelion
# file: mylib.py
def add(a, b):
return a+b
if __name__ == '__main__':
print(add(2, 3))
Cuando vuelva a importar el módulo en el intérprete de ipython, no se imprimirá 5 , que es la impresión que ya no se ejecuta.
Ejecutar el script python3 mylib.py en la línea de comandos ejecutará la instrucción de impresión porque el __name__ del módulo es __main__ .
El código que se evalúa con la condición __name__ == '__main__' suele ser el código de prueba para el módulo, o el código de ejemplo sobre cómo usar el módulo.
Resumen del módulo de Python
(1) Un archivo de Python es un módulo;
(2) Un módulo puede importar otros módulos;
(3) En el intérprete de Python en ejecución, un módulo solo se puede importar una vez, a menos que se use importlib.reload ();
(4) La instrucción ejecutable (no función, definición de clase) en el módulo se ejecuta solo una vez cuando se importa el módulo.
(5) Hay muchas formas de importar módulos, y la forma más estandarizada es utilizarla.
Módulo de práctica de Python.
Escriba su propio módulo de Python y cubra los puntos de conocimiento cubiertos en esta sección (5 puntos en resumen).
留言
張貼留言