En primer lugar, el módulo de introducción
En Python, un archivo de módulo py es un archivo denominado nombre del módulo xxx.py es xxx, módulo de importación puede hacer referencia al módulo de funciones se ha escrito. Si el proceso de desarrollo de la fabricación de comparar a un ordenador, escribir un módulo como en la fabricación de piezas de computadoras, piezas listas, todo lo que queda es lógicamente se reúnen juntos.
El programa modular hará que la estructura de la organización del programa más claro, más fácil de mantener. Comparado para dirigir el desarrollo de un programa completo, el desarrollo de un pequeño módulo único será más fácil, y módulos de programa y piezas de computadoras es ligeramente diferente: los módulos de programa pueden ser reutilizados. Así que la conclusión, el uso de los módulos de ambos para garantizar la reutilización del código, sino también mejorar el programa estructural y facilidad de mantenimiento. También, además de módulos personalizados, también podemos importar usos de características confeccionadas El built-in o módulo de terceros, este "ismo" ha mejorado en gran medida la eficiencia de los programadores de desarrollo.
1.1 ¿Qué es un módulo
Un módulo es un conjunto de una serie de funciones, divididos en tres categorías
Módulo incorporado
módulos de terceros
módulos personalizados
Un mismo módulo de Python es un archivo, el nombre del archivo m.py, módulo llamado m
Aprender: módulo se divide en cuatro formas
'''
1、使用python编写的.py文件
2、已被编译为共享库或DLL的c或c++扩展
3、把一系列模块组织到一起的文件夹(注：文件夹下有一个__init__.py文件，该文件夹称之为包)
4、使用c编写并链接到python解释器的内置模块
'''
1.2 ¿Por qué tener un módulo
- Incorporados y módulos de terceros utilizan para su uso, sin necesidad de definir, puede mejorar en gran medida su eficiencia en el desarrollo
- módulos personalizados: cada parte de la aplicación se pueden extraer en un bloque compartido por todas, para reducir la redundancia de código, estructura de organización de los programas con mayor claridad
En segundo lugar, el uso del módulo
2.1 declaración de importación
#文件名：foo.py
x=1
def get():
print(x)
def change():
global x
x=0
class Foo:
def func(self):
print('from the func')
Para citar archivo py en otra función foo.py, es necesario utilizar foo importación, primero importar el módulo va a hacer tres cosas:
1, la fuente de la ejecución de código de archivos
2, generar un nuevo espacio de nombres para el nombre del archivo de origen de ejecución generado procedimiento almacenado
3 para dar el nombre del espacio de archivos ejecutables actualmente reside en un nombre foo, señalando el nombre del espacio de nombres del módulo de nueva creación, una referencia al nombre del módulo de espacio de nombres, tenemos que añadir el prefijo, como sigue
import foo #导入模块foo
a=foo.x #引用模块foo中变量x的值赋值给当前名称空间中的名字a
foo.get() #调用模块foo的get函数
foo.change() #调用模块foo中的change函数
obj=foo.Foo() #使用模块foo的类Foo来实例化，进一步可以执行obj.func()
加上foo.作为前缀就相当于指名道姓地说明要引用foo名称空间中的名字，所以肯定不会与当前执行文件所在名称空间中的名字相冲突，并且若当前执行文件的名称空间中存在x，执行foo.get()或foo.change()操作的都是源文件中的全局变量x。
Ejecución py文件e importación py文件diferencia
# 执行py文件时,产生对应py文件的名称空间，当该py文件的程序执行结束时名称空间才被回收
# 导入py文件时，py文件被当作模块引用，第一次导入模块时产生模块的名称空间，即导入的py文件的名称空间
# 当被导入py文件不再被其他文件所引用，即导入的py文件的引用计数为0时才会被回收
'''
1、当foo.py被运行时，__name__的值为"__main__"
2、当foo.py被当作模块导入时，__name__的值为"foo"
if __name__ == '__main__':
print('文件被执行')
else:
print('文件被导入')
'''
# import的优缺点
'''
import导入模块在使用时必须加前缀"模块."
优点：肯定不会与当前名称空间的名字冲突
缺点：加前缀显得麻烦
'''
2.2 de importación-declaración
de importación ... ... consistentes con la declaración de importación, la única diferencia es la siguiente: después de usar módulo de importación foo importación,
nombres de los módulos de referencia que añadir foo. Como un prefijo, utilizado desde foo importación x, obtener, cambiar,
módulo foo foo puede hacer referencia directamente en el nombre del archivo que se está ejecutando actualmente de la siguiente manera
from foo import x,get,change #将模块foo中的x和get导入到当前名称空间
a=x #直接使用模块foo中的x赋值给a
get() #直接执行foo中的get函数
change() #即便是当前有重名的x，修改的仍然是源文件中的x
from...import...导入也发生了三件事
1、产生一个模块的名称空间
2、运行foo.py讲运行过程中产生的名字都丢到模块的名称空间
3、在当前名称空间拿到一个名字，该名字指向模块名称空间中的某一个内存地址
from foo import x # x=foo中1的内存地址
from foo import get
from foo import change
x=33333
print(x)
get()
change()
get()
print(x)
from foo import x # x=新的内存地址(0的内存地址)
print(x)
from...import...导入模块在使用时不用加前缀
'''
优点：代码更精简
缺点：容易与当前名称空间混淆
from foo import x # x=foo中1的内存地址
x=1111
'''
一行导入多个名字(不推荐)
from foo import x,get,change
*: 导入模块中的所有名字(大多数情况下不推荐使用，极容易与当前名称空间的名字混淆)
当你需要用到同一个模块中的多个名字时，
此时可以使用*来进行代码精简，但也需要权衡，避免与当前名称空间的名字混淆
了解：__all__ 控制*代表的名字有哪些
from foo import *
print(x)
print(get)
print(change)
起别名
from foo import get as g
*：导入模块中的所有名字
name='egon'
from foo import *
print(name)
Además del apoyo de la declaración de importación foo sintaxis, en nombre de la foo todos los nombres en la posición actual
from foo import *
#把foo中所有的名字都导入到当前执行文件的名称空间中，在当前位置直接可以使用这些名字
a=x
get()
change()
obj=Foo()
2.3 problemas de circulación de importación
Presentación de problema de circulación se refiere a la introducción de otro módulo en un proceso de carga / importación de módulo,
En un devuelto más de módulo de importación primer nombre del módulo, ya que el primer módulo
Finalización no se ha cargado, citó el fallo, emite una excepción, su raíz está en pitón,
Cuando un módulo con su código interno se realiza sólo en la primera introducción, introducido de nuevo en el módulo,
Incluso si el módulo no está todavía completamente cargada no repetir el código interno
# m1.py
print('正在导入m1')
# from m2 import y
def f1():
from m2 import y
print(y)
x='m1'
# m2.py
print('正在导入m2')
# from m1 import x
def f2():
from m1 import x
print(x)
y='m2'
# run.py
import m1
m1.f1()
prueba 1
#1、执行run.py会抛出异常
正在导入m1
正在导入m2
Traceback (most recent call last):
File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa练习目录/aa.py", line 1, in <module>
import m1
File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa练习目录/m1.py", line 2, in <module>
from m2 import y
File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa练习目录/m2.py", line 2, in <module>
from m1 import x
ImportError: cannot import name 'x'
#2、分析
先执行run.py--->执行import m1，开始导入m1并运行其内部代码--->打印内容"正在导入m1"
--->执行from m2 import y 开始导入m2并运行其内部代码--->打印内容“正在导入m2”--->执行from m1 import x,由于m1已经被导入过了，所以不会重新导入，所以直接去m1中拿x，然而x此时并没有存在于m1中，所以报错
Dos bancos de pruebas
#1、执行文件不等于导入文件，比如执行m1.py不等于导入了m1
直接执行m1.py抛出异常
正在导入m1
正在导入m2
正在导入m1
Traceback (most recent call last):
File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa练习目录/m1.py", line 2, in <module>
from m2 import y
File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa练习目录/m2.py", line 2, in <module>
from m1 import x
File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa练习目录/m1.py", line 2, in <module>
from m2 import y
ImportError: cannot import name 'y'
#2、分析
执行m1.py，打印“正在导入m1”，执行from m2 import y ，导入m2进而执行m2.py内部代码--->打印"正在导入m2"，执行from m1 import x，此时m1是第一次被导入，执行m1.py并不等于导入了m1，于是开始导入m1并执行其内部代码--->打印"正在导入m1"，执行from m1 import y，由于m1已经被导入过了，所以无需继续导入而直接问m2要y，然而y此时并没有存在于m2中所以报错
soluciones
# 方案一：导入语句放到最后，保证在导入时，所有名字都已经加载过
# 文件：m1.py
print('正在导入m1')
x='m1'
from m2 import y
# 文件：m2.py
print('正在导入m2')
y='m2'
from m1 import x
# 文件：run.py内容如下，执行该文件，可以正常使用
import m1
print(m1.x)
print(m1.y)
# 方案二：导入语句放到函数中，只有在调用函数时才会执行其内部代码
# 文件：m1.py
print('正在导入m1')
def f1():
from m2 import y
print(x,y)
x = 'm1'
# 文件：m2.py
print('正在导入m2')
def f2():
from m1 import x
print(x,y)
y = 'm2'
# 文件：run.py内容如下，执行该文件，可以正常使用
import m1
m1.f1()
注意：循环导入问题大多数情况是因为程序设计失误导致，上述解决方案也只是在烂设计之上的无奈之举，
在我们的程序中应该尽量避免出现循环/嵌套导入，如果多个模块确实都需要共享某些数据，
可以将共享的数据集中存放到某一个地方，然后进行导入
2.4 la prioridad módulo de búsqueda de ruta
De hecho, el módulo se divide en cuatro categorías generales, a saber:
1, puro código Python py archivo escrito
2, una serie de módulos que comprende un paquete
3, está escrito en C y enlazan con el intérprete de Python módulo integrado
4, el uso de la extensión compilador C o C ++
在导入一个模块时，如果该模块已加载到内存中，则直接引用，否则会优先查找内置模块，
然后按照从左到右的顺序依次检索sys.path中定义的路径，直到找模块对应的文件为止，
否则抛出异常。sys.path也被称为模块的搜索路径，它是一个列表类型
# 无论是import还是from...import在导入模块时都涉及到查找问题
# 优先级：
# 1、从内存找（内置模块）
# 2、按照sys.path中存放的文件的顺序依次查找要导入的模块
import sys
# 值为一个列表，存放了一系列的文件夹，
# 其中一个文件夹是当前执行文件所在的文件夹
print(sys.path)
# 了解：sys.modules查看已经加载到内存中的模块
# 针对模块的优化方案
import sys
import foo
def func():
import foo
func()
print(sys.modules)
# 找foo.py就把foo.py的文件夹临时添加到环境变量中
# 然后导入foo模块，程序结束append添加的环境变量就会被删除
sys.path.append(r'文件夹路径')
2.5 distinguir dos usos del archivo py
Un archivo tiene dos propósitos Python Una es cuando la ejecución del programa principal / escritura, cuando se introduce el módulo en el otro,
Con el fin de distinguir los diferentes usos del mismo archivo, cada uno tiene una función de las variables py archivo __name__,
Cuando se asigna la variable como un archivo de script se ejecuta py " principal ", asignada al nombre del módulo py cuando el archivo se importa como un módulo
#foo.py
...
if __name__ == '__main__':
print('文件被执行')
# foo.py被当做脚本执行时运行的代码
else:
print('文件被导入')
# foo.py被当做模块导入时运行的代码
Una especificación del módulo de escritura 2.6
Cuando en el archivo de preparación py, que necesitamos recordar que el documento no sólo para su propio uso, sino que también puede ser utilizada por otras personas, por lo que la legibilidad del código y la capacidad de mantenimiento es muy importante, y estamos escribiendo un módulo la mejor manera de escribir de acuerdo con normas uniformes
"The module is used to..." #模块的文档描述
import sys #导入模块
x=1 #定义全局变量,如果非必须,则最好使用局部变量,这样可以提高代码的易维护性,并且可以节省内存提高性能
class Foo: #定义类,并写好类的注释
'Class Foo is used to...'
pass
def test(): #定义函数,并写好函数的注释
'Function test is used to…'
pass
if __name__ == '__main__': #主程序
test() #在被当做脚本执行时,执行此处的代码