# Contenido de hoy
* Módulo de Importación
`` `Python
" ''
1. ¿Cuál es el módulo
módulo es (módulo os expediente de solicitud de procesamiento, el módulo de tiempo de aplicación) función de agregado de una serie de
módulos tienen tres fuentes
1. Módulo incorporado
Los módulos de terceros 2.
3 módulos personalizados
módulo de cuatro formato de rendimiento
1. Utilice el archivo py escrito en Python
2 ha sido compilada como una librería compartida o DLL C o C ++ extensiones
3. armar una serie de módulos organizados en carpetas (carpeta existe __init__.py una carpeta de archivos llamado paquete)
4. escrito en C y está conectado con el módulo incorporado intérprete de python
2. ¿Por qué se utiliza el módulo
1. El uso de los módulos integrados o de terceros beneficios son: ISM, mejorará en gran medida la eficiencia del desarrollo
2. Uso beneficia módulos personalizados son: procedimientos de extracción necesitan utilizar más lugares públicos el módulo de función se define como la reducción de código redundante
(el programa es un multi-archivo, varios archivos tendrán que utilizar todas las funciones en un mismo lugar para todo el mundo para encontrar la unidad)
3. ¿Cómo utilizar módulos
premisa: hay que distinguir quién es el archivo ejecutable, que es un módulo que ser importados
"" "
` ``
#### el uso de importación
Python `` `
" ""
Nuevo archivo de ejecución de dos py se introduce
"""
# md.py
de impresión ( 'desde el md.py')
Dinero = 1000
DEF Read1 ():
print ( 'MD', dinero)
Read2 DEF ():
print ( 'módulo MD')
Read1 ()
DEF Cambio ():
Global Money
Money = 0
# run.py
dinero = 66
importación nombre de archivo # md es el nombre del módulo y md md.py
# Derecho de gestión, ejecute el archivo md, múltiples importaciones no se ejecutarán más de una vez
. "" "
1. La primera importación de tres cosas ocurre módulo
1. genera un módulo de espacio de nombres
2. Ejecutar el archivo md.py, llevará a cabo nombre generado en el proceso se colocan en el espacio de nombres del módulo
'dinero': dirección de memoria 1000
'read1': la función de memoria de direcciones read1
'read2': la función de memoria de direcciones read2
'cambio': dirección de memoria función de cambio de
icono entender mejor el efecto
3. nombre del módulo para conseguir un espacio en el nombre del archivo ejecutable actual, que señala al nombre del módulo de espacio de nombres
que es:
Ahora ejecute el archivo md, sin duda va a crear un espacio de nombres, todos los nombres de archivo md relación vinculante con el valor de ahorrar hasta un
plazo también ejecutar un archivo, sin duda va a crear un espacio de nombres, el dinero fue a la tienda md
'dinero': dirección de memoria 66 de la
'MD': nombre del espacio de direcciones de md.py
2. después de la importación es una referencia directa a los resultados de la primera importación no se vuelve a ejecutar el fichero
"" "
sintaxis # 1. realice el nombre de archivo de espacio de nombres del módulo de acceso: el nombre del nombre del módulo
de impresión (md.money) # nombre nombre de la vía del archivo que desea dar nombre con md dinero, ciertamente no en conflicto con el nombre del archivo que se está ejecutando
en el espacio de nombres actual del dinero para realizar fichero dinero #
Imprimir (md.read1)
Imprimir (md.read2)
Imprimir (md.change) # de impresión para obtener la dirección de memoria de la función realizada por el impulso >>> corchetes
# Una llamada read1, read2, cambiar limpiar varias veces para encontrar el nombre de la ley
md.read1 () # md buscar un archivo en Money
md.read2 () # busca de dinero archivo md
md.change () # modificada archivo md es dinero
La introducción de una pluralidad de módulos # línea (no se recomienda)
Importación OS, SYS, Tiempo
desde introdujo al módulo # Nombre Alias
XXXYYY importación como xy
"" "
Importar Importa Resumen del módulo:
debe ser prefijado cuando está en uso: el nombre del módulo.
Ventajas: por su nombre a un nombre a un espacio de nombres, desde luego no en conflicto con los actuales nombres de espacio de nombres
Contras: Cuando el empleo el módulo tendrá que añadir el nombre del módulo prefijo
"" "
` ``
### from ... import ...
`` `Python
# todavía por encima de dos documentos, por ejemplo
a partir md dinero importación
de md dinero importación
" ''
de importación ... ... tres cosas han tenido lugar, antes de que ambos importación como de importación, sólo la última un poco diferente
1. genera un módulo de espacio de nombres
2. ejecute el md.py archivo, el nombre del proceso de implementación se generan en el módulo de espacio de nombres
3. directa para obtener un nombre de archivo en la aplicación actual de la correspondiente al nombre del módulo es el nombre de
'dinero': dinero archivo md
"" "
# 1.
el dinero = 888
desde md importación dinero
# 2.
del md dinero importación
de moneda = 888
# Resumen
"" "
ventajas: no es necesario utilizar el prefijo más, más concisos
Contras: que el nombre del actual conflicto en el espacio de nombres
" ""
de MD importación Read1
dinero = 999
se ha fijado Read1 () Signatura función en la fase de definición muerto, no hay ninguna relación con la ubicación de llamadas aquí es sólo la aplicación del nombre de espacio de nombres de archivo modificado! ! ! Ilustra apreciado
# otro ejemplo pruebas
Chang () # valor se modifica, la implementación del archivo de módulo de dinero señaló que el dinero nada
de impresión (dinero)
# Aprender
de importación md * # * representantes para obtener todos los nombres (no se recomienda) de los módulos importados, ya que el nombre pueda entrar en conflicto con el nombre del espacio actual
# * suplemento de importación __all__ es __all__ interior una lista de los nombres de
`` `
módulo de importación ### ciclos
Python `` `
" ""
Módulo
m1.py
print ( 'que se importa M1')
de M2 y # Importación tres cosas a ocurrir en la primera importación
X = 'M1'
m2.py
impresión ( 'que se importa m2')
importar el X-M1 de
los = y- 'M2'
ejecute el archivo
run.py
importación M1 # tres cosas primera importación a suceder
. "" "
# análisis paso a paso, lleva a cabo la primera carrera, correr para producir el correspondiente espacio de nombres
# importación M1, ya que se primera importación creará un espacio de nombres m1 correspondiente
código es # ejecutar M1 se encuentra en m1 y guiar el m2, m2 es la primera importación
# crea espacio de nombres m2, realizan m2 código
# m2 en la necesidad de encontrar en m1 x esta vez no ha hecho fuera de x
"" "
el problema con este fenómeno está circulando importado, la guía M1 m2, m2 M1 a su vez a guiar el
surgimiento de medios de circulación importó el diseño de su programa no es razonable, es necesario rediseñar
" " "
# Resolver los problemas causados por el ciclo de importaciones
manera # 1: el ciclo de estado importado en el nombre detrás de la definida
impresión ( 'que se importa M1')
los ejes X = 'M1'
de la importación y-M2
imprimir ( 'M2 de ser introducido')
Y = 'M2'
de M1 X Importación
# Realización 2: La declaración bucle introducido en la función
de impresión ( 'ser importados M1')
DEF F1 ():
a partir de M2 Importación Y
print ( 'm1.f1 >>> Y:', Y)
X = 'M1'
print ( 'de ser introducido M2')
DEF F2 ():
a partir de M1 X Importación
print ( 'm2.f2 >>> X:', X)
Y = 'M2'
# ilustrado apreciado
# Resumen: Antes de importar, listo para dejar su nombre
`` `
#### archivo juicio py se importa como un módulo o archivo ejecutable
Python `
SI el __name__ == '__main__': # cuando se lleva a cabo directamente un archivo
si __name__ == 'py nombre de archivo' # Cuando se importa un archivo
`
Encontrar el orden de ### módulos
`` `Python
" ''
módulo de secuencia de consulta
1. Empezar a buscar puede haber sido cargado en la memoria del
2 módulo incorporado
lista 3.sys.path dentro de un trazado que se miran el uno
necesita saber la lista de la primera ruta sys.path es la imagen actual es la carpeta en la ejecución
ps: módulo de Python también soporta la importación directamente desde el archivo zip en
"" "
# Validar el primer punto, en busca de encontrar un módulo de memoria empezar a buscar para ver módulo no está ya cargado
. "" "
Definir un módulo, importados en otro archivo, y luego ejecutar los años 10 el sueño activo de archivos, rápida para tomar la palabra durante el módulo eliminar el archivo, encontrar el código después de la ejecución del archivo todavía se puede acceder a dormir
, pero una vez que los acabados programa en ejecución, el error será de nuevo realizar la
importación de tiempo de
importación M1
del time.sleep (10)
importación M1
m1.f1 ()
"" "
# Tenga en cuenta que nombre de archivo py de su nuevo mejor no módulo de tiempo de conflictos de nombre de módulo ya existente, por ejemplo
`` `
#### casos un poco más complicado
`` Python `
# Para desactivar el módulo en una carpeta, ejecutar archivos y carpetas con diferentes niveles al mismo módulo de nivel de archivo
md importación. # Salvado porque no hay memoria, incorporado no lo hizo, sys.path es ejecutar el archivo actual se encuentra carpeta para buscar el archivo
# con el fin de resolver, necesidad de uso sys.path.append () a la carpeta en la que el módulo de archivo añadido a la misma
# No quieren resolver con lo anterior, se puede utilizar en los siguientes modos
de importación ... ...
md de importación dir1.dir2
`` `
importación absoluta módulo ###
`` `Python
# nuevamente subrayado: los módulos importados que dejar claro el archivo ejecutable y el archivo de importación, sys.path se basa en la carpeta donde se ejecuta el archivo
- la importación del módulo absoluta
-dir1
-m1.py
-m2.py
-run .py
archivos de M1 # carpeta de importación dir1 donde el run.py archivo ejecutable es "importar absolutamente módulo" a la carpeta se pueden encontrar bases dir1 y por lo tanto se pueden encontrar dentro de la m1
# Un ejemplo más para confundir a la gente
- la importación absoluta módulo
-dir1
-m1.py
-m2.py
-run.py
# M1 M2 directamente guía
# Y luego estudiar de nuevo
- absolutamente importación módulo
-dir0
-dir1
-m1.py
-m2.py
-run.py
# módulo para importar todos los archivos están sujetos a cabo archivo
# pueden utilizar sys.path.appen ser añadido a dir0 variable de entorno
"" "
Resumen: comienza a ejecutar el archivo (basado en sys.path) encontrar la relación entre las capas, los llamados absoluto de importación
ventajas: archivo ejecutable que se importen con el módulo puede ser utilizado
Desventajas: Se requiere que todos importaciones a sys.path a juego punto de partida, la importación de problemas
. "" "
` ``
La introducción del módulo #### relativa
`` `Python
" ''
importaciones en relación con: archivo de referencia actualmente reside en la carpeta a partir Encuentra
El documento representa la ubicación actual de la carpeta de archivos
.., en nombre de una carpeta
... en nombre de un nivel superior carpeta
ventaja: importación más ágil
desventajas: sólo se pueden utilizar en el módulo se importa, el archivo no puede ser ejecutada con
"" "
# Tenga en cuenta, sin embargo, las importaciones en relación sólo puede ser utilizado en la carpeta módulo importado, el archivo no se puede ejecutar usado
paquete #
Tres fuentes hablan módulo de módulo cuando se le habla del formato de cuatro rendimiento
`` `Python
módulo tiene tres fuentes
1. Módulo incorporado
Los módulos de terceros 2.
3. módulos personalizados
cuatro tipos de módulo de formato rendimiento
1. Uso py pitón documento escrito
2. Se ha compilado como una biblioteca compartida o DLL C o C ++ extensiones
3. la serie de módulos agrupados en la carpeta (una carpeta de archivo __init__.py, la carpeta llamada paquete)
4. escrito en C y está conectado a la incorporada en el módulo de interpretación pitón
El origen de los módulos de presentación y paquetes #
"" "
¿Qué es un paquete
de archivos que contiene el paquete es una carpeta de archivos __init__.py
esencialmente módulos pueden ser importados, los archivos también se incluyen dentro del paquete que se utilizará para la importación
2. ¿Por qué debe empacar
carpetas se utilizan para mejorar la gestión de archivos, y los diseñadores de paquetes es facilitar un mejor módulo de módulo de organización
. "" "
# Construir una carpeta que contiene una __init__.py (P1) fue construido en el mismo nivel de archivo py en el proceso de análisis de la carpeta
. "" "
Los recuerdos de los módulos importados tres cosas
1. Generar un espacio de nombres de módulo de
módulo 2. Ejecución código en el nombre del archivo será generado durante la ejecución son arrojados al espacio de nombres
3. obtener el nombre de la que se está ejecutando un archivo, el nombre está apuntando al módulo de espacio de nombres
Pregunta: El segundo paso es importar los documentos de ejecución del código de módulo, ahora es una carpeta, a continuación, el ejecutivo que hace que la tiró?
paquete de importación deduce tres cosas
1. Archivos __init__.py en el paquete como una referencia para generar un espacio de nombres
2. Ejecutar el código en el paquete de archivos __init__.py, se genera el nombre durante la ejecución se tiran espacio de nombres
3. obtener el nombre de un archivo en la ejecución actual P1, P1 es el punto de espacio de nombres __init__.py
"" "
# python3 verificar si una carpeta que no contiene __init__.py tampoco está dando
# conmutación python2 encontró para dirigir el error
# python2 que está dentro del paquete debe tener __init__ archivo, pitón incluso si no hay error no lo hará
# Compruebe el paquete de importación es el archivo de punto __init__.py
# acceso Nombre del módulo, de hecho, ir __init__.py archivo para encontrar el nombre de
`` `
#### Encuentra nombre
`` `Python
# derivación anterior paquete de guía apunta realmente __init__.py archivo para acceder al nombre de archivo basado en el interior, por lo que bien podría construir un archivo py
# importar el paquete se encuentra dentro del paquete todo el nombre del archivo py y el archivo no sólo __init__
"" "
No vayas por ahí, hablando demasiado complicado para hablar directamente con los dos ángulos
El primer ángulo: el usuario paquete de
paquete de usuario después de que el envase acabado descarga, sólo asegúrese de encontrar la ruta en el paquete en su programa normal de interior y de importación
a saber, el uso de variables de entorno para manipular sys.path
el paquete se encuentra en una ruta de la carpeta a la variable de entorno (las necesidades del usuario a saber es el módulo de descarga o un paquete donde se encuentra una carpeta, sólo tiene que descargar un software, que sin duda tiene que saber dónde ir después)
declaraciones de importación. La dejaron sin duda debe ser un paquete
El segundo ángulo: Los desarrolladores de paquetes
para asegurar que todos los módulos son capaces de escribir su propio paquete de nivel superior __init__.py encontrar utilizando el módulo de importación en relación con
los beneficios son los aspectos más destacados:
1. Módulo de cambio de nombre no afecta a la interna de consulta
2. No se se debe confundir con el concepto de capas anidadas de relaciones y ejecutar archivos en el archivo
"" "
` ``