python学习日记（模块导入）

什么是模块？

常见的场景：一个模块就是一个包含了python定义和声明的文件，文件名就是模块名字加上.py的后缀。

但其实import加载的模块分为四个通用类别：　

　　1 使用python编写的代码（.py文件）

　　2 已被编译为共享库或DLL的C或C++扩展

　　3 包好一组模块的包

　　4 使用C编写并链接到python解释器的内置模块

为何要使用模块？

如果你退出python解释器然后重新进入，那么你之前定义的函数或者变量都将丢失，因此我们通常将程序写到文件中以便永久保存下来，需要时就通过python test.py方式去执行，此时test.py被称为脚本script。

随着程序的发展，功能越来越多，为了方便管理，我们通常将程序分成一个个的文件，这样做程序的结构更清晰，方便管理。这时我们不仅仅可以把这些文件当做脚本去执行，还可以把他们当做模块来导入到其他的模块中，实现了功能的重复利用。

如何使用模块？

import

示例文件：自定义模块my_module.py，文件名my_module.py,模块名my_module

print('from my_module.py')

x = 100
def read1():
    print('my_module->read1->x',x)
def read2():
    print('my_module->read2->x',x)
    read1()
def change():
    global x
    x = 0

重复导入的问题

模块可以包含可执行的语句和函数的定义，这些语句的目的是初始化模块，它们只在模块名第一次遇到导入import语句时才执行（import语句是可以在程序中的任意位置使用的,且针对同一个模块很import多次,为了防止你重复导入，python的优化手段是：第一次导入后就将模块名加载到内存了，后续的import语句仅是对已经加载大内存中的模块对象增加了一次引用，不会重新执行模块内的语句），如下

import my_module
import my_module
import my_module

我们可以从sys.modules中找到当前已经加载的模块，sys.modules是一个字典，内部包含模块名与模块对象的映射，该字典决定了导入模块时是否需要重新导入。

import my_module
import sys
print(sys.modules)

模块与本地的变量冲突问题

每个模块都是一个独立的名称空间，定义在这个模块中的函数，把这个模块的名称空间当做全局名称空间，这样我们在编写自己的模块时，就不用担心我们定义在自己模块中全局变量会在被导入时，与使用者的全局变量冲突啦

一、x与my_module.x不冲突

import my_module
x = 50
print(my_module.x)

二、read1与my_module.read1不冲突

import my_module
def read1():
    print('local_test_read1')
my_module.read1()

三、执行my_module.change()操作的全局变量x仍然是my_module中的

import my_module
x = 50
my_module.change()
print(x)
print(my_module.x)

总结

总结：首次导入模块my_module时会做三件事：

1.为源文件(my_module模块)创建新的名称空间，在my_module中定义的函数和方法若是使用到了global时访问的就是这个名称空间。

2.在新创建的命名空间中执行模块中包含的代码，见初始导入import my_module

1 提示:导入模块时到底执行了什么？
2
3 In fact function definitions are also ‘statements’ that are ‘executed’; the execution of a module-level function definition enters the function name in the module’s global symbol table.
4 事实上函数定义也是“被执行”的语句，模块级别函数定义的执行将函数名放入模块全局名称空间表，用globals()可以查看

导入模块时到底执行了什么？

3.创建名字my_module来引用该命名空间

1 这个名字和变量名没什么区别，都是‘第一类的’，且使用my_module.名字的方式可以访问my_module.py文件中定义的名字，my_module.名字与test.py中的名字来自两个完全不同的地方。

模块别名

为模块起别名，相当于a = 1,b = a

import my_module as m
print(m.x)

示范用法一：

有两中sql模块mysql和oracle，根据用户的输入，选择不同的sql功能

#分别创建两个数据库模块
#mysql.py
def sqlparse():
    print('from mysql slparse')
#oracle.py
def sqlparse():
    print('from oracle sqlparse')

db_type = input('please input db_name:')
if db_type.strip().lower() == 'mysql':
    import mysql as db
elif db_type.strip().lower() == 'oracle':
    import oracle as sb

db.sqlparse()

示范用法二：

为已经导入的模块起别名的方式对编写可扩展的代码很有用，假设有两个模块xmlreader.py和csvreader.py，它们都定义了函数read_data(filename):用来从文件中读取一些数据，但采用不同的输入格式。可以编写代码来选择性地挑选读取模块，例如

if file_format == 'xml':
     import xmlreader as reader
elif file_format == 'csv':
     import csvreader as reader
data=reader.read_date(filename)

注意：模块在定义了别名之后，使用就只能用别名。

一行导入多个模块

import os,sys,re

from...import...

简述

Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中，语法如下：

from modname import name1[, name2[, ... nameN]]

例如，要导入模块 modname 的 name1 函数，使用如下语句：

from modname import name1

这个声明不会把整个modname模块导入到当前的命名空间中，它只会将modname里的name1函数引入进来。

#测试一：导入的函数read1，执行时仍然回到my_module.py中寻找全局变量 x
from my_module import read1
x = 0.1
read1()
print('分割线'.center(20,'-'))
#测试二:导入的函数read2，执行时需要调用read1(),仍然回到my_module.py中找read1()
from my_module import read2
def read1():
    print('')
read2()

覆盖情况

导入的函数read1，被当前位置定义的read1覆盖掉了

from my_module import read1 def read1(): print('') read1()

注意：绑定关系

需要特别强调的一点是：python中的变量赋值不是一种存储操作，而只是一种绑定关系，如下：

from my_module import x,read1
x = 0.1#将当前位置的名字x绑定到了100
print(x)#打印当前的名字
read1()#读取my_module.py中的名字x,仍然为100

也可重命名

from my_module import read1 as r
r()

也可导入多行

from my_module import (x,
                       read1,
                       read2)

from … import *

简述

from my_module import * 把my_module中所有的不是以下划线(_)开头的名字都导入到当前位置，大部分情况下我们的python程序不应该使用这种导入方式，因为*你不知道你导入什么名字，很有可能会覆盖掉你之前已经定义的名字。而且可读性极其的差，在交互式环境中导入时没有问题。

这种声明不该被过多地使用。

from my_module import *
print(x)
print(read1)
print(read2)
print(change)

__all__

如果没有这个变量，就会导入模块中所有的名字

如果有这个变量，就只导入__all__列表中的名字

__all__ = ['read1']#这样在另外一个文件中用from my_module import *就这能导入列表中规定的一个名字

__name__

一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。

说明： 每个模块都有一个__name__属性，当其值是'__main__'时，表明该模块自身在运行，否则是被引入。

说明：__name__ 与 __main__ 底下是双下划线， _ _ 是这样去掉中间的那个空格。

import my_module as m
if m.__name__ == '__main__':
    print('程序自身在运行')
else:
    print('我来自另一个模块')
print('分割线'.center(15,'-'))
#自身
if __name__ == '__main__':
    print('程序自身在运行')
else:
    print('我来自另一个模块')

pass