自定义模块

1
2
3
4
5
6
7
8
9
10
11
12
模块就是一个python文件而已，所有python代码都可以放如模块，实际开发中，模块放入的内容都是
重复利用率高的内容主要包含：
  1.为当前模块专门定义的变量【其他语言一般都是常量】
  2.函数。
  3.类
  4.测试代码

测试代码统一放到判断当中
  if __name__ == '__main__':
    测试代码

自定义的模块不可以与已存在的模块名重复，优先级相同文件夹下的模块更大。

模块的搜索路径：

1
2
3
导入模块的时候程序查找指定模块的文件夹的路径的集合。
import sys
print(sys.path)

常用搜索路径(windows)

1
2
3
4
5
6
当前导入模块的文件所在的文件夹
    仅仅是一个普通的程序文件，为当前文件夹下的文件使用的模块
（python安装目录中的Lib文件夹）C:\Users\xdl\AppData\Local\Programs\Python\Python37\Lib
    表示为python扩展功能，适用于所有使用当前环境的程序【为了全人类】
第三方模块的目录\Lib\site-packages（C:\Users\xdl\AppData\Local\Programs\Python\Python37\Lib\site-packages）
    也是为python扩展功能，相当于用户为自己环境扩展的而不是为整个python扩展的【为了自己】
1
2
3
#自己添加，添加搜索路径[后面的操作]
import sys
sys.path.append('C:\\Users\\xdl\\Desktop')

模块的导入

  • import
1
2
import 模块名
直接导入整个模块
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#导入自定义的模块 my_01
import my_01

#使用模块中的内容
#变量
print(my_01.NAME)
print(my_01.SEX)
print(my_01.AGE)

#函数
my_01.smile()
my_01.cry()

#类
dmn = my_01.GF()
print(dmn)
dmn.cook()
1
2
import 模块名 as 别名
使用别名导入模块，适用于模块名称较长的模块
1
2
3
4
#别名导入
import random as rd
#使用模块中的内容
print(rd.randint(10,100))
  • from import
1
2
3
from 模块名 import 某个内容
导入模块中的指定内容。
注意：该方式是将模块中的内容直接导入当前脚本当中，访问不需要模块名称
1
2
3
4
from os import getcwd
#使用模块中的内容(仅仅需要getcwd功能)
print(getcwd())
# print(getenv('PATH')) 不可使用，没有导入
1
2
3
from 模块名 import 内容1,内容2,内容3....
导入模块中的指定的多个内容。
注意：该方式是将模块中的内容直接导入当前脚本当中，访问不需要模块名称
1
2
3
4
5
6
from os import getcwd,getenv
#使用功能
print(getcwd())
print(getenv('PATH'))
#无法使用其他内容
#print(os.F_OK)
1
2
3
from 模块名 import *
导入模块中的所有内容
注意：该方式是将模块中的内容直接导入当前脚本当中，访问不需要模块名称
1
2
3
4
5
6
#直接使用from imprt *
from os import *
#可以使用os中所有内容
print(getcwd())
print(getenv('PATH'))
print(F_OK)

警告：使用from … import 语法必须确定 模块中的内容不会和当前脚本中的内容重名。

包

文件夹。所以包就是一个同的文件夹在python中的称呼。

1
2
3
4
5
6
7
8
9
10
11
包的结构：
  包（文件夹）
  |----  __init__.py  包的标志文件（可以有内容，也可以是空的！）
  |----  模块1（文件）
  |----  模块2（文件）
  |----  ...
  |----  子包（文件夹中的文件夹）
  |----- |----  __init__.py  包的标志文件（可以有内容，也可以是空的！）
  |----- |---- 模块3
  |----- |---- 模块4
  |----- |---- ...

包的导入

  • import
1
2
3
4
5
import 包名
导入包本身，但是不一定能够导入内容.

import animal_01
help(animal_01)
1
2
3
4
5
6
import 包名.模块名
导入包中的指定模块。

import animal_01.cat
print(animal_01.cat.NAME)
animal_01.cat.say()
1
2
3
4
5
import 包名.子包名
导入子包本身，但是不一定能够导入内容.

import animal_01.human
help(animal_01.human)
1
2
3
4
5
6
7
import 包名.子包名.子模块
导入包中子包中的模块

import animal_01.human.woman
animal_01.human.woman.cry()
animal_01.human.woman.nao()
animal_01.human.woman.diao()
1
2
3
4
5
所有import 语法允许使用as语法
import animal_01.human.woman as wm
wm.cry()
wm.nao()
wm.diao()
  • from import
1
2
3
4
5
6
7
8
from 包 import 模块
从包中导入一个模块

from animal_01 import cat
#可以直接使用cat模块
print(cat)
cat.say()
print(cat.NAME)
1
2
3
4
5
6
7
8
#from 包 import 模块1,模块2...
丛包中导入者多个模块

from animal_01 import cat,dog
#使用cat模块中的内容
cat.say()
#使用dog模块中的内容
dog.say()
1
2
3
4
from 包 import 子包
从包中导入子包,无法使用模块中的信息

from animal_01 import human
1
2
3
4
5
6
7
from 包.子包 import 模块
导入包中子包中的模块

from animal_01.human import woman
woman.cry()
woman.nao()
woman.diao()
1
2
3
4
5
6
from 包中.子包.模块 import 内容
导入包中子包中模块的一个或者内容

from animal_01.human.woman import diao,nao
diao()
nao()

init.py文件

1
2
3
4
5
6
__all__ 特殊变量:
  1.包是文件夹一般不能够存储信息。
  2.__init__.py文件除了当做包的标志之外，还可以为包本身存储信息，使得包具有模块的内容
  3.在__init__.py文件中，如果设置了__all__变量，并且使用from import语法导入包本身
      __init__.py中除了__all__的设置之外，其余设置均会失效
  4.__all__变量的作用在使用from 包 import *的导入方式之下，可以设定当前包导入时所使用的模块
  • my_package03只有init
1
2
3
4
5
6
7
init中没有__all__并且存在以下内容：

#声明变量
name = '包子'
#函数
def hot():
  print('热包子烫手~')
1
2
3
4
5
6
7
8
9
10
import my_package03
#使用包中的功能
print(my_package03.name)
my_package03.hot()

#使用from import语法
from my_package03 import * #必须*
#使用包中的功能
print(name)
hot()
1
2
3
4
init中有__all__后，声明的name、hot（）不可调用

#添加变量
__all__ = ['chick','duck','dog']
1
2
3
4
5
6
7
8
9
10
##使用from import语法
from my_package03 import *

#hot()   #找不到此方法
#可以使用小鸡模块中的信息
print(chick.name)
#可以使用鸭子模块中的信息
print(duck.name)
#可以使用小狗模块中的信息
print(dog.name)

相对导入与绝对导入方式：

  • 绝对导入

绝对导入方式会使用【搜索路径】查找指定的包或者模块的所在，如以上的导入。

  • 相对导入

import 语法无法使用的 !

1
2
3
from .包名/模块名 import 内容     导入当前包中模块中的内容
from ..包名/模块名 import 内容    导入上层包中的模块的内容
查找方式：在当前文件夹中搜索查找指定的包或者模块
1
2
3
4
5
6
7
8
9
10
11
12
#在a模块中 导入当前包中b模块中的内容
from .b import bbb   #bbb变量会导入到当前文件中，当前文件中有bbb变量
#在当前文件中 导入当前包中c子包中c模块中的内容
from .c.c import ccc
aaa = '111'

#导入包4中的a模块
import my_package04.a
#使用a文件中内容
print(my_package04.a.aaa)
print(my_package04.a.bbb)
print(my_package04.a.ccc)
1
2
3
4
5
6
7
8
9
10
#在子包c中的d模块中导入上层包中的b模块的内容
from ..b import *
ddd = '444'

#导入包4中子包c中的d文件
import my_package04.c.d
#d模块只有一个内容
print(my_package04.c.d.ddd)
#可以使用b模块中的内容
print(my_package04.c.d.bbb)