1、包（Package）概述

包（Package）是用来存储相关程序结构的对象，它存储于数据字典中。包由两部分组成：包规范(PACKAGE)和包体(PACKAGE BODY)。

包规范是包的说明部分，是对外的操作接口（类似java接口），对应用是可见的。

包体是包的代码和实现部分（类似java实现类），对应用来说是不可见的。

1.1 包说明

公有元素(PUBLIC)    在包头中说明，在包体中具体定义。在包外可见并可以访问，对整个应用的全过程有效。
私有元素(PRIVATE)  在包体的说明部分说明。只能被包内部的其他部分访问。
局部变量(LOCAL)     在过程或函数的说明部分说明。只能在定义变量的过程或函数中使用。

1.2 系统包

包名称	描述
DBMS_OUTPUT	在SQL*Plus环境下输出信息
DBMS_DDL	编译过程函数和包
DBMS_SESSION	改变用户的会话,初始化包等
DBMS_TRANSACTION	控制数据库事务
DBMS_MAIL	连接Oracle*Mail
DBMS_LOCK	进行复杂的锁机制管理
DBMS_ALERT	识别数据库事件告警
DBMS_PIPE	通过管道在会话间传递信息
DBMS_JOB	管理Oracle的作业
DBMS_LOB	操纵大对象
DBMS_SQL	执行动态SQL语句

2、基本语法

2.1 创建包和包体

1.创建包规范语法：
        CREATE [OR REPLACE] PACKAGE 包名 IS|AS
           --变量(VARIABLE)定义
           --常量(CONSTANT)定义
           --游标(CURSOR)定义
           --类型(TYPE)定义
           --函数定义
           FUNCTION 函数名 [(参数列表)] RETURN 返回类型;
           --存储过程定义
           PROCEDURE 存储过程名 [(参数列表)];
           异常(EXCEPTION)
        END [包名]; 

2.创建包体语法：
        CREATE [OR REPLACE] PACKAGE BODY 包名 IS|AS
           --...
           --函数实现
           FUNCTION 函数名 [(参数列表)] RETURN 返回类型 IS|AS
           --函数实现内容
           --存储过程实现
           PROCEDURE 存储过程名 [(参数列表)] IS|AS
           --存储过程实现内容
       END [包名];

2.2 其它语法

--1 删除包规范
DROP PACKAGE 包规范名

--2 删除包体
DROP PACKAGE BODY 包体名

--3 重新编译包头
ALTER PACKAGE 包名 COMPILE PACKAGE

--4 重新编译包体
ALTER PACKAGE 包名 COMPILE PACKAGE BODY

2.3 注意要点

1 包说明和包体必须有相同的名字
2 包的开始没有BEGIN语句，与存储过程和函数不同。
3 在包的说明部分定义函数和过程的名称和参数，具体实现在包体中定义。
4 在包内声明常量、变量、类型定义、异常、及游标时不使用DECLARE。
5 包内的过程和函数的定义不要CREATE OR REPLACE语句。
6 包定义和包体两者分离。
7 只有当包头编辑成功后才能编辑包体。
8 函数名与过程名须和包头中的函数过程一样。

3、包的应用

以下所涉及的表，请查看Oracle进阶（三）常用函数的附表。

3.1 包创建

CREATE OR REPLACE PACKAGE EMP_PK   
        --包定义部分   
          IS  
				--公有变量：员工人数
         V_EMP_COUNT NUMBER(5);
				--公有过程：初始化数据
         PROCEDURE INIT(P_MAX NUMBER,P_MIN NUMBER);
				--公有过程:显示员工列表 
         PROCEDURE LIST_EMP;
				 --公有过程:新增员工
         PROCEDURE INSERT_EMP(P_EMPNO NUMBER,P_ENAME VARCHAR2,P_JOB VARCHAR2,P_SAL NUMBER);
				 --公有过程：删除员工
         PROCEDURE DELETE_EMP(P_EMPNO NUMBER);
				 --公有过程:修改员工工资
         PROCEDURE CHANGE_EMP_SAL(P_EMPNO NUMBER,P_SAL NUMBER);
        END EMP_PK;  
        
          /
   
        CREATE OR REPLACE PACKAGE BODY EMP_PK
        --包体部分   
          IS  
         --私有变量：输出信息
         V_MESSAGE VARCHAR2(50);
         --私有变量:可修改工资上限 
         V_MAX_SAL NUMBER(7);
         --私有变量:可修改工资下限  
         V_MIN_SAL NUMBER(7);
         --私有函数:判断员工是否存在
         FUNCTION EXIST_EMP(P_EMPNO NUMBER)  RETURN  BOOLEAN;
         --私有过程:显示信息
         PROCEDURE SHOW_MESSAGE;
         --INIT
         PROCEDURE INIT(P_MAX NUMBER,P_MIN NUMBER)   
          IS   
         BEGIN  
          SELECT COUNT(*) INTO V_EMP_COUNT FROM EMP;  
          V_MAX_SAL:=P_MAX;  
          V_MIN_SAL:=P_MIN;  
          V_MESSAGE:='初始化数据已完成！';  
          SHOW_MESSAGE;   
         END INIT;  
         --LIST_EMP
         PROCEDURE LIST_EMP   
          IS   
         BEGIN  
          DBMS_OUTPUT.PUT_LINE('姓名       职务      工资');  
          FOR EMP_REC IN (SELECT ENAME,JOB,SAL FROM EMP)  
          LOOP  
           DBMS_OUTPUT.PUT_LINE(RPAD(EMP_REC.ENAME,10,' ')||RPAD(EMP_REC.JOB,10,' ')||TO_CHAR(EMP_REC.SAL));  
          END LOOP;  
          DBMS_OUTPUT.PUT_LINE('员工总人数'|| V_EMP_COUNT);  
         END LIST_EMP;  
        --INSERT_EMP 
         PROCEDURE INSERT_EMP(P_EMPNO NUMBER,P_ENAME VARCHAR2,P_JOB VARCHAR2,P_SAL NUMBER)  
          IS   
         BEGIN  
          IF NOT EXIST_EMP(P_EMPNO) THEN  
           INSERT INTO EMP(EMPNO,ENAME,JOB,SAL)VALUES(P_EMPNO,P_ENAME,P_JOB,P_SAL);  
           COMMIT;   
           V_EMP_COUNT:=V_EMP_COUNT+1;  
           V_MESSAGE:='员工'||P_EMPNO||'已新增!';  
          ELSE  
           V_MESSAGE:='员工'||P_EMPNO||'已存在,不能新增!';  
          END IF;  
           SHOW_MESSAGE;   
         EXCEPTION  
          WHEN OTHERS THEN  
          V_MESSAGE:='员工'||P_EMPNO||'新增失败!';  
          SHOW_MESSAGE;  
         END INSERT_EMP;  
        --DELETE_EMP
         PROCEDURE DELETE_EMP(P_EMPNO NUMBER)   
          IS   
         BEGIN   
          IF EXIST_EMP(P_EMPNO) THEN  
           DELETE FROM EMP WHERE EMPNO=P_EMPNO;  
           COMMIT;  
           V_EMP_COUNT:=V_EMP_COUNT-1;  
           V_MESSAGE:='员工'||P_EMPNO||'已删除!';  
          ELSE  
           V_MESSAGE:='员工'||P_EMPNO||'不存在，不能删除!';  
          END IF;  
          SHOW_MESSAGE;  
         EXCEPTION  
          WHEN OTHERS THEN  
          V_MESSAGE:='员工'||P_EMPNO||'删除失败!';  
          SHOW_MESSAGE;  
         END DELETE_EMP;  
         --CHANGE_EMP_SAL  
         PROCEDURE CHANGE_EMP_SAL(P_EMPNO NUMBER,P_SAL NUMBER)   
          IS   
         BEGIN   
          IF (P_SAL>V_MAX_SAL OR P_SAL<V_MIN_SAL) THEN  
           V_MESSAGE:='工资超出修改范围!';  
          ELSIF NOT EXIST_EMP(P_EMPNO) THEN  
           V_MESSAGE:='员工'||P_EMPNO||'不存在，不能修改工资!';  
          ELSE  
           UPDATE EMP SET SAL=P_SAL WHERE EMPNO=P_EMPNO;  
           COMMIT;  
           V_MESSAGE:='员工'||P_EMPNO||'工资已经修改!';  
          END IF;  
           SHOW_MESSAGE;  
         EXCEPTION  
          WHEN OTHERS THEN  
          V_MESSAGE:='员工'||P_EMPNO||'工资修改失败!';  
          SHOW_MESSAGE;  
         END CHANGE_EMP_SAL;  
        --SHOW_MESSAGE
         PROCEDURE SHOW_MESSAGE   
          IS   
         BEGIN  
          DBMS_OUTPUT.PUT_LINE('提示信息：'||V_MESSAGE);  
         END SHOW_MESSAGE;  
         --EXIST_EMP
         FUNCTION EXIST_EMP(P_EMPNO NUMBER)  
         RETURN BOOLEAN   
          IS
         --局部变量：员工数量
         V_NUM NUMBER;
         BEGIN  
          SELECT COUNT(*) INTO V_NUM FROM EMP WHERE EMPNO=P_EMPNO;  
          IF V_NUM=1 THEN   
            RETURN TRUE;  
          ELSE  
           RETURN FALSE;  
          END IF;   
         END EXIST_EMP;  

        END EMP_PK; 

3.2 包调用

--调用包

--1 初始化
BEGIN
  EMP_PK.INIT(P_MAX => 200,
              P_MIN => 100);
END;

--2 员工列表
CALL EMP_PK.LIST_EMP();

--3 新增员工
CALL EMP_PK.INSERT_EMP(2021,'一二山人','YESR',10000); 
 
--4 查看员工人数
BEGIN  
    DBMS_OUTPUT.PUT_LINE(EMP_PK.V_EMP_COUNT);  
END;

--5 删除员工
CALL EMP_PK.DELETE_EMP(2021); 

--6 修改工资
CALL EMP_PK.CHANGE_EMP_SAL(7900,150); 

--7 授权其他用户调用包
GRANT EXECUTE ON EMP_PK TO SYS;  

--8 其它用户SYS调用包
CALL SCOTT.EMP_PK.INIT(400,300); 

4、包的进阶

4.1 包重载创建

CREATE OR REPLACE PACKAGE EMP_OVERLOAD_PK IS
   --过程：新增部门
   PROCEDURE INSERT_DEPT (
       P_DEPTNO   DEPT.DEPTNO%TYPE,    --部门编号
       P_DNAME    DEPT.DNAME%TYPE,     --部门名称
       P_LOC      DEPT.LOC%TYPE        --位置
    );   
   --过程：新增部门（重载）
   PROCEDURE INSERT_DEPT (
       P_DEPTNO   DEPT.DEPTNO%TYPE,    --部门编号
       P_DNAME    DEPT.DNAME%TYPE     --部门名称
    );       
    --函数：获取员工加薪
    FUNCTION GET_ADDSALARY (P_EMPNO EMP.EMPNO%TYPE)
       RETURN NUMBER;

    --函数：获取员工加薪(重载)
    FUNCTION GET_ADDSALARY (P_ENAME EMP.ENAME%TYPE)
       RETURN NUMBER;                  
END EMP_OVERLOAD_PK;

/

CREATE OR REPLACE PACKAGE BODY EMP_OVERLOAD_PK
IS
    FUNCTION EXIST_DEPT(P_DEPTNO DEPT.DEPTNO%TYPE)  RETURN  NUMBER;
  --INSERT_DEPT
  PROCEDURE INSERT_DEPT (
       P_DEPTNO   DEPT.DEPTNO%TYPE,
       P_DNAME    DEPT.DNAME%TYPE,
       P_LOC      DEPT.LOC%TYPE
    )
    AS
       BEGIN
       IF EXIST_DEPT(P_DEPTNO) > 0  --如果部门存在
       THEN                            --抛出异常
          RAISE_APPLICATION_ERROR (-2021, '出现了相同的员工记录');
       END IF;
       INSERT INTO DEPT(DEPTNO, DNAME, LOC)
            VALUES (P_DEPTNO, P_DNAME, P_LOC);--新增
						COMMIT;
    END INSERT_DEPT;
--INSERT_DEPT（重载）
  PROCEDURE INSERT_DEPT (
       P_DEPTNO   DEPT.DEPTNO%TYPE,
       P_DNAME    DEPT.DNAME%TYPE
    )
    AS
       BEGIN
       IF EXIST_DEPT(P_DEPTNO) > 0 --如果部门存在
       THEN                            --抛出异常
          RAISE_APPLICATION_ERROR (-2022, '出现了相同的员工记录');
       END IF;
       INSERT INTO DEPT(DEPTNO, DNAME, LOC)
            VALUES (P_DEPTNO, P_DNAME, '广州天河区');--新增记录
						COMMIT;
    END INSERT_DEPT;

    --GET_ADDSALARY
    FUNCTION GET_ADDSALARY (P_EMPNO EMP.EMPNO%TYPE)
       RETURN NUMBER
    IS
       V_JOB           EMP.JOB%TYPE;
       V_SAL           EMP.SAL%TYPE;
       V_SALARYRATIO   NUMBER (10, 2);--调薪比率
    BEGIN
       --获取员工表中的薪资信息
       SELECT JOB, SAL INTO V_JOB, V_SAL FROM EMP WHERE EMPNO = P_EMPNO;
       CASE V_JOB
          WHEN 'CLERK' THEN
             V_SALARYRATIO := 1.05;
          WHEN 'SALESMAN' THEN
             V_SALARYRATIO := 1.1;
          WHEN 'MANAGER' THEN
             V_SALARYRATIO := 1.2;
          ELSE
             V_SALARYRATIO := 1;
       END CASE;
       IF V_SALARYRATIO <> 1
       THEN
          RETURN ROUND(V_SAL * V_SALARYRATIO,2);
       ELSE
          RETURN V_SAL;
       END IF;
     EXCEPTION
          WHEN NO_DATA_FOUND THEN
             RETURN 0;
     END GET_ADDSALARY;

    --GET_ADDSALARY（重载）
    FUNCTION GET_ADDSALARY (P_ENAME EMP.ENAME%TYPE)
       RETURN NUMBER
    IS
       V_JOB           EMP.JOB%TYPE;
       V_SAL           EMP.SAL%TYPE;
       V_SALARYRATIO   NUMBER (10, 2);--调薪比率
    BEGIN
       --获取员工表中的薪资信息
       SELECT JOB, SAL INTO V_JOB, V_SAL FROM EMP WHERE ENAME = P_ENAME;
       CASE V_JOB
          WHEN 'CLERK' THEN
             V_SALARYRATIO := 1.05;
          WHEN 'SALESMAN' THEN
             V_SALARYRATIO := 1.1;
          WHEN 'MANAGER' THEN
             V_SALARYRATIO := 1.2;
          ELSE
             V_SALARYRATIO := 1;
       END CASE;
       IF V_SALARYRATIO <> 1
       THEN
          RETURN ROUND(V_SAL * V_SALARYRATIO,2);
       ELSE
          RETURN V_SAL;
       END IF;
     EXCEPTION
          WHEN NO_DATA_FOUND THEN
             RETURN 0;
     END GET_ADDSALARY;

    --私有函数：部门是否存在
    FUNCTION EXIST_DEPT(P_DEPTNO DEPT.DEPTNO%TYPE) RETURN NUMBER
    AS
      V_COUNT NUMBER(2);
    BEGIN
       SELECT COUNT(*) INTO V_COUNT FROM DEPT WHERE DEPTNO=P_DEPTNO;
       RETURN V_COUNT;
    END;
END EMP_OVERLOAD_PK;

4.2 包重载调用

--调用
BEGIN
	 EMP_OVERLOAD_PK.INSERT_DEPT(50,,);
END
--重载过程
BEGIN
  EMP_OVERLOAD_PK.INSERT_DEPT(P_DEPTNO => 50,
                              P_DNAME =>'交付二部',
                              P_LOC => '海珠区');
END;
--过程
BEGIN
  EMP_OVERLOAD_PK.INSERT_DEPT(P_DEPTNO => 60,
                              P_DNAME =>'交付一部');
END;
----重载函数
DECLARE
   V_SAL NUMBER(10,2);
BEGIN
   V_SAL:=EMP_OVERLOAD_PK.GET_ADDSALARY(7369);
	 DBMS_OUTPUT.PUT_LINE('获取员工加薪'|| V_SAL); 
END;
--函数
DECLARE
   V_SAL NUMBER(10,2);
BEGIN
   V_SAL:=EMP_OVERLOAD_PK.GET_ADDSALARY('SMITH');
	 DBMS_OUTPUT.PUT_LINE('获取员工加薪'|| V_SAL); 
END;

 

一、模块

相信使用过Python编写代码的同学，会经常在文件头看到这样的import …，是的，这就是导入模块的语句，而每一个后缀名为.py的文件都是一个模块。

import jieba
import os　

1. 什么是模块？

  逻辑上来说模块是一组功能的组合；实质上一个模块就是一个包含了python定义和声明的文件，文件名就是模块名字加上.py的后缀。

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

a. 使用python编写的代码（.py文件）；
b. 已被编译为共享库或DLL的C或C++扩展；
c. 包好一组模块的包
d. 使用C编写并链接到python解释器的内置模块；

如何使用模块？
　　想要使用模块，必须先要将模块加载进来，可以通过关键字 import 或 from进行加载；需要注意的是模块和当前文件在不同的命名空间中。

2. 模块的构成：

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

二、模块的导入

1、导入整个模块

  比如我们有一个myModule的文件夹，里面有一个first.py文件，文件中的内容如下

a = 1
def myfun(s):
    print(s + 1)

  在myModule的文件夹下打开终端/cmd，输入python进入命令行交互模式
写完模块导入的语句之后，接着就可以调用该模块下的函数了。调用方式为

>>> import first
>>> a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined
>>> first.a
1
>>> first.myfun(2)
3

2、导入特定的函数/变量

  所以说first.py文件就是一个模块，可以用import导入，里面变量和方法都要用first.前缀来引用，如果想不使用这个前缀或是我们只是想要使用模块中的某个函数，就可以只导入该变量或函数。导入方式为：from module_name import function_name。
  如果导入的是变量，就可以直接输入变量名来获得变量的值；如果直接导入的是函数，可以直接使用function_name() 的方式调用函数，无需在函数名前面加上模块名。

# 导入变量
>>> from first import a
>>> a
1
# 导入函数
>>> from first import myfun
>>> myfun(3)
4
# 一次导入多个变量
>>> from first import a,myfun
>>> a
1
>>> myfun(5)
6
# 导入模块中全部变量
>>> from first import *
>>> a
1
>>> myfun(5)
6
>>>

3、使用as给模块指定别名

  可以在后面使用as给函数指定别名。句式如：import module_name as new_name，

>>> import first as f
>>> f.a
1
>>> f.myfun(6)
7

在上述导入函数的基础上，可以在后面用as语句给导入的函数指定别名。句式如：from module_name import function_name as new_function。

>>> from first import myfun as add
>>> add(8)
9

三、模块、包、库的区别

模块(module) 其实就是py文件，里面定义了一些函数、类、变量等。
包(package) 是多个模块的聚合体形成的文件夹，里面可以是多个py文件，也可以嵌套文件夹。
库是参考其他编程语言的说法，是指完成一定功能的代码集合，在python中的形式就是模块和包。

四、包的导入

导入包的本质：导入一个包就是执行包下的__init__.py文件

只要一个文件夹下面有个 init.py 文件，那么这个文件夹就可以看做是一个包。

包导入的过程和模块的基本一致，只是导入包的时候会执行此包目录下的 init.py 而不是模块里面的语句了。另外，如果只是单纯的导入包，而包的 init.py 中又没有明确的其他初始化操作，那么此包下面的模块是不会自动导入的。

下面我们来实操进行说明

在myModule文件夹中新建folder文件夹，先cd进入myModule文件夹，在mkdir folder新建folder文件夹

xws@MHQ0063 myModule % mkdir folder

我们想让folder文件夹成为一个包。文件夹里新建abcd.py文件，输入vi abcd.py，文件中内容如下

b = 2

class Myclass:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def get_info(self):
        print('my name is {name} and age is {age}'.format(name = self.name, age = self.age))

esc–>:wq退出保存

此时在folder文件夹中新建一个__init__.py文件，否则程序会将这个文件夹当成普通文件夹来处理而不是一个包。这个__init__.py文件中可以什么都不填。

上面步骤操作下来，文件结构如下

我们还是在myModule文件夹下打开命令行，进入python交互模式

>>> import folder
>>> folder.abcd.b
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute 'abcd'
# 只是导入包不能随便使用其中的模块，要导入到具体模块或者变量的层次

>>> from folder import abcd
>>> bob = abcd.Myclass(name = 'Bob', age = 20)
>>> bob.name
'Bob'
>>> bob.get_info()
my name is Bob and age is 20
>>> from folder.abcd import b
>>> b
2
>>> import folder.abcd
>>> abcd.b
2
>>> import folder.abcd as a
>>> a.b
2

注意：

• 只是导入包不能随便使用其中的模块，要导入到具体模块或者变量的层次
• 文件夹与文件之间可以用.也可以用from import格式，而文件与里面的变量之间只能用from import格式，即不能import folder.abcd.b

特殊的__init__.py文件

init.py文件其实是一个特殊的文件，它相当于名为folder模块，即如果使用import folder则可以调用在__init__.py文件文件中定义的变量。

将__init__.py文件编写如下

from folder.abcd import b
c = 3

在myModule文件夹下打开命令行，进入python交互模式

>>> import folder
>>> folder.c
3
>>> folder.b
2
>>> from folder import b
>>> b
2

对比之前的from folder.abcd import b，使用__init__.py文件可以将常用的一些变量导入以方便调用。

另外需要注意两点

1. __ init__ .py文件编写时，如果要导入其他模块中的变量，即使__ init__.py文件和abcd.py文件在同一个文件夹下，也不能from abcd import b，要从abcd文件从哪里来开始写，即从包的名称开始，from folder.abcd import b。
2. folder文件夹里的嵌套文件夹内不需要新建__init__.py文件即可像模块一样调用，但是一般还是要新建这个文件，可以方便地导入常用变量。

用import hello时，python会搜寻hello.py文件，搜索顺序如下
先搜寻内置模块是否有hello（因此我们定义的模块名不能内置模块相同）
若内置模块没有，则看以下这些目录里有没有

>>> import sys
>>> sys.path
['', '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python27.zip', '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7', '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/plat-darwin', '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/plat-mac', '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/plat-mac/lib-scriptpackages', '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/lib-tk', '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/lib-old', '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/lib-dynload', '/Users/xws/Library/Python/2.7/lib/python/site-packages']

其中第一个’‘表示当前的工作路径，我们可以看出安装的第三方包所在路径(‘/Users/xws/Library/Python/2.7/lib/python/site-packages’)也在这个列表之中，所以无论工作路径在哪里，都能搜寻到这些包。建议把模块放在该文件夹下。

__ all __

import *的方式无法导入以下划线开头的变量名_e = 4

__ init__.py文件内容更改如下

from folder.abcd import b
c = 3
_e = 4

python模式下，以下导入方式，在查找变量_e是会报name ‘_e’ is not defined

>>> from folder import *
>>> c
3
>>> _e
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name '_e' is not defined

但如果指定导入_e便可以

>>> from folder import c
>>> c
3
>>> from folder import _e
>>> _e
4

如果定义了__all__，则import *就可以导入下划线开头的变量

__ init__.py文件内容更改如下

from folder.abcd import b
__all__ = ['c', '_e']
c = b + 1
_e = 4

>>> from folder import *
>>> b
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'b' is not defined
>>> c
3
>>> _e
4

由上面的输出结果，我们可以知道import *只会导入__all__中指定的变量，无论是否以下划线开头。这样限制可以防止import *命令导入太多变量污染命名空间，过滤掉一些中间变量如b

五、模块导入的绝对引用与相对引用

python中的import分为绝对引用和相对引用两种。它们之间的差异在于，引用模块时，定位被引用模块位置 的方式不同。

绝对引用是通过.的连接，指定出最高级文件（夹），到目标文件的绝对路径。我们上面的所有用法都属于绝对引用。

而相对引用是指定待引用模块与当前文件的相对位置，.表示上一级文件

• 绝对引用：from folder.abcd import myclass
• 相对引用：from .abcd import myclass

在实际使用中，无论是绝对导入还是相对导入都要注意，如何导入与被调用位置有关。

以下面的文件结构为例
folder1
  │ first1.py
  │ first2.py
  │ init.py
  │
  └─folder2
    second1.py
    second2.py
    init.py

下面分为两种情况

1. folder1是一个项目。运行这个项目需要在folder文件夹中打开cmd，运行python first1.py
   
   此时first1.py文件中引用first2.py中变量只需from first2 import sth
   不可以from folder1.first2 import sth，也不可以 from .first2 import sth
   (即使folder1中有定义_init_.py，在文件夹内部打开cmd仍无法搜索到folder1的名称)
   
   first1.py文件中引用second1.py中变量需要from folder2.second1 import sth
   second1.py文件中引用second2.py中变量需要from folder2.second2 import sth
   或者使用相对引用方法：from .second2 import sth
   (注意first1引用first2 与 second1引用second2 的区别)

2. folder1是一个包。一般使用时，是在外面的文件夹中import这个包
   
   此时first1.py文件中引用first2.py中变量需要from folder1.first2 import sth
   或者from .first2 import sth
   不可以 from first2 import sth，即使两个first文件在同一个文件夹内
   
   从上面两个例子的对比中我们可以看出，一个项目内的文件之间，相互引用变量时，如何import是要看这个项目是在什么文件中调用的，也可以说要看这些文件和调用处之间的相对位置。

import运行本质

使用import语句，要明确两件事

（1）执行导入模块命令时，会首先检查待导入的模块是否在当前已有模块之中，如果有则跳过import。因此模块之间相互引用不会导致无限循环。

查看当前已导入模块使用下面方法

import sys
sys.modules

得到结果是一个字典，键是模块名，值是文件所在路径

（2）import语句与文件执行

在这样的文件结构下

myModule
  | first.py
  |───folder
  |   | abcd.py
  |   | __ init __.py

folder是一个package，abcd是一个module

import folder只是导入package，相当于执行__ init__ .py文件
from folder import abcd则执行了__ init __ .py文件文件与abcd.py文件
from folder.abcd import b其实也执行了 __ init __ . py 文件文件与abcd.py文件
（要知道执行了什么，可以在这些文件之中添加print语句，看是否打印出结果）

知道这个执行原理，可以更好理解前面得到的一些结论

首先是在__init__.py文件中什么都没有的情况下，import folder无法调用abcd模块中的变量，是因为相当与运行了一个空文件，没有将整个包导入工作空间
abcd模块中定义了print语句后，import两次，只有第一次会print出值，说明第二次检查出模块已在导入之列，忽略了这条import命令

六、if __ name__ == '__ main__'有什么作用

我们经常会在代码中看到这一句 if __ name__ == ‘__ main__’ ，为了理解它的作用，我们来看下面的例子

在folder文件夹下新建new.py文件，里面内容为

print(__name__)

在folder文件夹下打开命令行，输入

python new.py

返回结果

xws@MHQ0063 folder % python new.py
__main__

在myModule文件夹下打开命令行，进入python交互模式

>>> from folder import new
folder.new
>>> print(__name__)
__main__
>>> print(new.__name__)
folder.new

从测试结果可以发现直接运行文件和import文件是有差异的，差异在于二者的__ name__ 变量不同。__ name__ 变量是一个特殊的变量，每个py文件运行时都会对应一个 __ name__变量，即使在交互模式下也可以查看这个变量值。

所以 if __ name__ == '__ main__'的作用就很好理解了，即import时不执行下面的代码，只有在直接执行这个文件时才运行之后的代码。这算是一种约定俗成的写法，如果不怕文件被import，可以不用这个。

七、os模块

import os 是导入标准库os
os(operation system)import os
os(Operation System)操作系统

有了OS模块，我们不需要关心什么操作系统下使用什么模块，OS模块会帮你选择正确的模块并调用

参考python模块详解