⑴ 盘点python常用的模块和包
模块
1.定义
计算机在开发过程中，代码越写越多，也就越难以维护，所以为了编写可维护的代码，我们会把函数进行分组，放在不同的文件里。在python里，一个.py文件就是一个模块。
2.优点：
提高代码的可维护性。
提高代码的复用，当模块完成时就可以在其他代码中调用。
引用其他模块，包含python内置模块和其他第三方模块。
避免函数名和变量名等名称冲突。
python内建模块：
1.sys模块
2.random模块
3.os模块：
os.path:讲解
https://www.cnblogs.com/yufeihlf/p/6179547.html
数据可视化
1.matplotlib :
是Python可视化程序库的泰斗，它的设计和在1980年代被设计的商业化程序语言MATLAB非常接近。比如pandas和Seaborn就是matplotlib的外包，它们让你能用更少的代码去调用 matplotlib的方法。
访问：
https://matplotlib.org/
颜色：
https://www.cnblogs.com/darkknightzh/p/6117528.html
教程：
https://wizardforcel.gitbooks.io/matplotlib-user-guide/3.1.html
2.Seaborn：
它是构建在matplotlib的基础上的，用简洁的代码来制作好看的图表。Seaborn跟matplotlib最大的区别就是它的默认绘图风格和色彩搭配都具有现代美感。
访问：
http://seaborn.pydata.org/index.html
3.ggplot：
gplot 跟 matplotlib 的不同之处是它允许你叠加不同的图层来完成一幅图
访问：
http://ggplot.yhathq.com/
4.Mayavi：
Mayavi2完全用Python编写，因此它不但是一个方便实用的可视化软件，而且可以方便地用Python编写扩展，嵌入到用户编写的Python程序中，或者直接使用其面向脚本的API：mlab快速绘制三维图
访问：http://code.enthought.com/pages/mayavi-project.html
讲解：https://blog.csdn.net/ouening/article/details/76595427https://www.jianshu.com/p/81e6f4f1cdd8
5.TVTK：
TVTK库对标准的VTK库进行包装，提供了Python风格的API、支持Trait属性和numpy的多维数组。
VTK (http://www.vtk.org/) 是一套三维的数据可视化工具，它由C++编写，包涵了近千个类帮助我们处理和显示数据
讲解：https://docs.huihoo.com/scipy/scipy-zh-cn/tvtk_intro.html
机器学习
1.Scikit-learn
是一个简单且高效的数据挖掘和数据分析工具，易上手，可以在多个上下文中重复使用。它基于NumPy, SciPy 和 matplotlib，开源，可商用（基于 BSD 许可）。
访问：
讲解：https://blog.csdn.net/finafily0526/article/details/79318401
2.Tensorflow
最初由谷歌机器智能科研组织中的谷歌大脑团队（Google Brain Team）的研究人员和工程师开发。该系统设计的初衷是为了便于机器学习研究，能够更快更好地将科研原型转化为生产项目。
相关推荐：《Python视频教程》
Web框架
1.Tornado
访问：http://www.tornadoweb.org/en/stable/
2.Flask
访问：http://flask.pocoo.org/
3.Web.py
访问：http://webpy.org/
4.django
https://www.djangoproject.com/
5.cherrypy
http://cherrypy.org/
6.jinjs
http://docs.jinkan.org/docs/jinja2/
GUI 图形界面
1.Tkinter
https://wiki.python.org/moin/TkInter/
2.wxPython
https://www.wxpython.org/
3.PyGTK
http://www.pygtk.org/
4.PyQt
https://sourceforge.net/projects/pyqt/
5.PySide
http://wiki.qt.io/Category:LanguageBindings::PySide
科学计算
教程
https://docs.huihoo.com/scipy/scipy-zh-cn/index.html#
1.numpy
访问
http://www.numpy.org/
讲解
https://blog.csdn.net/lm_is_dc/article/details/81098805
2.sympy
sympy是一个Python的科学计算库，用一套强大的符号计算体系完成诸如多项式求值、求极限、解方程、求积分、微分方程、级数展开、矩阵运算等等计算问题
访问
https://docs.sympy.org/0.7.1/guide.html#guide
讲解
https://www.jianshu.com/p/339c91ae9f41
解方程
https://www.cnblogs.com/zyg123/p/10549354.html
3.SciPy
官网
https://www.scipy.org/
讲解
https://blog.csdn.net/wsp_1138886114/article/details/80444621
4.pandas
官网
http://pandas.pydata.org/
讲解
https://www.cnblogs.com/linux-wangkun/p/5903945.html
5.blaze
官网
http://blaze.readthedocs.io/en/latest/index.html
密码学
1.cryptography
https://pypi.python.org/pypi/cryptography/
2.hashids
http://www.oschina.net/p/hashids
3.Paramiko
http://www.paramiko.org/
4.Passlib
https://pythonhosted.org/passlib/
5.PyCrypto
https://pypi.python.org/pypi/pycrypto
6.PyNacl
http://pynacl.readthedocs.io/en/latest/
爬虫相关
requests
http://www.python-requests.org/
scrapy
https://scrapy.org/
pyspider
https://github.com/binux/pyspider
portia
https://github.com/scrapinghub/portia
html2text
https://github.com/Alir3z4/html2text
BeautifulSoup
https://www.crummy.com/software/BeautifulSoup/
lxml
http://lxml.de/
selenium
http://docs.seleniumhq.org/
mechanize
https://pypi.python.org/pypi/mechanize
PyQuery
https://pypi.python.org/pypi/pyquery/
creepy
https://pypi.python.org/pypi/creepy
gevent
一个高并发的网络性能库
http://www.gevent.org/
图像处理
bigmoyan
http://scikit-image.org/
Python Imaging Library(PIL)
http://www.pythonware.com/procts/pil/
pillow：
http://pillow.readthedocs.io/en/latest/
自然语言处理
1.nltk：
http://www.nltk.org/
教程
https://blog.csdn.net/wizardforcel/article/details/79274443
2.snownlp
https://github.com/isnowfy/snownlp
3.Pattern
https://github.com/clips/pattern
4.TextBlob
http://textblob.readthedocs.io/en/dev/
5.Polyglot
https://pypi.python.org/pypi/polyglot
6.jieba：
https://github.com/fxsjy/jieba
数据库驱动
mysql-python
https://sourceforge.net/projects/mysql-python/
PyMySQL
https://github.com/PyMySQL/PyMySQL
PyMongo
https://docs.mongodb.com/ecosystem/drivers/python/
pymongo
MongoDB库
访问：https://pypi.python.org/pypi/pymongo/
redis
Redis库
访问：https://pypi.python.org/pypi/redis/
cxOracle
Oracle库
访问：https://pypi.python.org/pypi/cx_Oracle
SQLAlchemy
SQL工具包及对象关系映射（ORM）工具
访问：http://www.sqlalchemy.org/
peewee，
SQL工具包及对象关系映射（ORM）工具
访问：https://pypi.python.org/pypi/peewee
torndb
Tornado原装DB
访问：https://github.com/bdarnell/torndb
Web
pycurl
URL处理工具
smtplib模块
发送电子邮件
其他库暂未分类
1.PyInstaller：
是一个十分有用的第三方库，它能够在Windows、Linux、 Mac OS X 等操作系统下将 Python 源文件打包，通过对源文件打包， Python 程序可以在没有安装 Python 的环境中运行，也可以作为一个 独立文件方便传递和管理。
2.Ipython
一种交互式计算和开发环境
讲解
https://www.cnblogs.com/zzhzhao/p/5295476.html
ls、cd 、run、edit、clear、exist
⑵ 在python 中如何 import 父目录中的模块
在 python 中，如果当前目录中存在有 __init__.py 文件，则表示该目录为一个包(package)，在包中，引用同级目录或子目录中的其它模块非常简单，直接使用 import 语句即可，并且如果是同级目录，没有 __init__.py 文件亦可。但如何导入父目录中的其它模块呢，在 python 的世界里，没有像 C 中直接使用 ../ 来退级的方式，像 import ../test 这样的语句是不合法的。其它，如果理工清楚了 import 语句的工作原理，就好办了，import 工作时，就是根据模块名，从 sys.path 所包含的路径中寻找对应的模块名，如果能找到，则将其它导入到当前运行环境，根据这个规则，有如下两种方式解决上述问题：
1、修改 sys.path 法：在导入父目录中的模块前，先修改 sys.path 的值，如导入父目录中的 test 模块，导入方法如下：import syssys.path.insert(0, "..") ;# or�0�2 sys.path.append("..")
2、将包的根目录以外链的形式加入到 sys.path 中，即在 {PYTHON-HOME}\lib\site-packages 中新建一个 .pth 文件，文件内容为包根路径，假设包的根目录为 d:/py/mytest/，则可以在 {PYTHON-HOME}\lib\site-packages 目录下建一个 mytest.pth 的文件，内容为 d:/py/mytest。完成上述步骤后，则可以在任何模块中像导入已安装的系统包一样导入 mytest 包或是该包下的所有模块，如 import mytest。注意，由于 python 的版本不同，在 v2.5 版以后，需要在 __init__.py 文件中显示地使用 __all__ 变量指明当前包下有哪些模块，要不此包是无法正常导入和工作地
⑶ python导入子目录的子目录的模块,提示找不到
其实你的描述不是很清楚 子目录是绑定域名的么 通过什么域名来访问？ 因为这个程序的数据库连接用的地址最前面加了/，是相对于根目录而言的所以如果是http://域名/子目录 来访问的话 就更改为Const ACCESSPATH="/子目录/######/shotan.mdb" '数据库路径
Const BACKACCESSPATH="/子目录/######/#shotan.mdb" '备份数据库路径 或者另外一个方法就是用父路径来表示，那就看你的conn.asp相对于网站首页的位置如果与首页就是当前这个网站的根目录相同文件夹，就去掉开始的/，改成Const ACCESSPATH="######/shotan.mdb" '数据库路径
Const BACKACCESSPATH="######/#shotan.mdb" '备份数据库路径 如果conn.asp在某个文件夹里，比如include文件夹，就加个父路径../，改成Const ACCESSPATH="../######/shotan.mdb" '数据库路径
Const BACKACCESSPATH="../######/#shotan.mdb" '备份数据库路径 后面这种方法比较适合于把网站放在任何地方 然后其他的比如图片，flash，css的连接地址也如同数据库一样修改
⑷ Python导入模块问题
Python是一种面向对象的编程语言，里面包含有丰富强大的库，想要学习Python开发，首先需要学习如何导入模块或包。下面就跟大家一起讨论下Python导入模块的几种方法：
常规导入
最常用的导入方式，大概是这样的：
import sys
只需要使用 import ，然后指定希望导入的模块或包即可。用这种方法导入的好处是可以一次性导入多个包或模块：
import os, sys, time
虽然这节省了空间，但是却违背了Python风格指南。 Python风格指南建议将每个导入语句单独成行 。
有时在导入模块时，你想要重命名这个模块。这个功能很容易实现：
import sys as system
print(system.platform)
上面的代码将我们导入的 sys 模块重命名为 system 。我们可以按照和以前一样的方式调用模块的方法，但是可以用一个新的模块名。也有某些子模块必须要使用点标记法才能导入。
import urllib.error
这个情况不常见，但是对此有所了解总是没有坏处的。
使用from语句导入
有时我们只想要导入一个模块或库中的某个部分。那么Python是如何实现这点：
from functools import lru_cache
上面这行代码可以让你直接调用 lru_cache 。如果按常规方式导入 functools ，那么就必须像这样调用 lru_cache ：
functools.lru_cache(*args)
根据实际的使用场景，上面的做法可能是更好的。在复杂的代码库中，能够看出某个函数是从哪里导入的这点很有用的。不过，如果你的代码维护的很好，模块化程度高，那么只从某个模块中导入一部分内容也是非常方便和简洁的。
当然，你还可以使用from方法导入模块的全部内容，就像这样：
from os import *
这种做法在少数情况下是挺方便的，但是这样也会打乱你的命名空间。问题在于，你可能定义了一个与导入模块中名称相同的变量或函数，这时如果你试图使用
os 模块中的同名变量或函数，实际使用的将是你自己定义的内容。因此，你最后可能会碰到一个相当让人困惑的逻辑错误。
标准库中我唯一推荐全盘导入的模块只有Tkinter 。
如果你正好要写自己的模块或包，有人会建议你在 __init__.py 文件中导入所有内容，让模块或者包使用起来更方便。我个人更喜欢显示地导入，而非隐式地导入。
你也可以采取折中方案，从一个包中导入多个项：
from os import path, walk, unlinkfrom os import uname, remove
在上述代码中，我们从 os 模块中导入了5个函数。你可能注意到了，我们是通过多次从同一个模块中导入实现的。当然，如果你愿意的话，你也可以使用圆括号一次性导入多个项：
from os import (path, walk, unlink, uname,
remove, rename)
这是一个有用的技巧，不过你也可以换一种方式：
from os import path, walk, unlink, uname, \
remove, rename
上面的反斜杠是Python中的续行符，告诉解释器这行代码延续至下一行。
相对导入
PEP 328 介绍了引入相对导入的原因，以及选择了哪种语法。具体来说，是使用句点来决定如何相对导入其他包或模块。这么做的原因是为了避免偶然情况下导入标准库中的模块产生冲突。这里我们以PEP 328中给出的文件夹结构为例，看看相对导入是如何工作的：
my_package/
__init__.py
subpackage1/
__init__.py
mole_x.py
mole_y.py
subpackage2/
__init__.py
mole_z.py
mole_a.py
在本地磁盘上找个地方创建上述文件和文件夹。在顶层的 __init__.py 文件中，输入以下代码：
from . import subpackage1from . import subpackage2
接下来进入 subpackage1 文件夹，编辑其中的 __init__.py 文件，输入以下代码：
from . import mole_xfrom . import mole_y
现在编辑 mole_x.py 文件，输入以下代码：
from .mole_y import spam as ham
def main():
ham()
最后编辑 mole_y.py 文件，输入以下代码：
def spam():
print('spam ' * 3)
打开终端， cd 至 my_package 包所在的文件夹，但不要进入 my_package 。在这个文件夹下运行Python解释器。我使用的是IPython，因为它的自动补全功能非常方便：
In [1]: import my_package
In [2]: my_package.subpackage1.mole_xOut[2]: <mole
'my_package.subpackage1.mole_x' from
'my_package/subpackage1/mole_x.py'>
In [3]: my_package.subpackage1.mole_x.main()spam spam spam
相对导入适用于你最终要放入包中的代码。如果你编写了很多相关性强的代码，那么应该采用这种导入方式。
你会发现PyPI上有很多流行的包也是采用了相对导入 。还要注意一点，如果你想要跨越多个文件层级进行导入，只需要使用多个句点即可。不过， PEP
328建议相对导入的层级不要超过两层 。
还要注意一点，如果你往 mole_x.py 文件中添加了 if __name__ == ‘__main__’ ，然后试图运行这个文件，你会碰到一个很难理解的错误。编辑一下文件，试试看吧！
from . mole_y import spam as ham
def main():
ham()
if __name__ == '__main__':
# This won't work!
main()
现在从终端进入 subpackage1 文件夹，执行以下命令：
python mole_x.py
如果你使用的是Python 2，你应该会看到下面的错误信息：
Traceback (most recent call last):
File "mole_x.py", line 1, in <mole>
from . mole_y import spam as hamValueError: Attempted relative import in non-package
如果你使用的是Python 3，错误信息大概是这样的：
Traceback (most recent call last):
File "mole_x.py", line 1, in <mole>
from . mole_y import spam as hamSystemError: Parent mole '' not loaded, cannot perform relative import
这指的是， mole_x.py 是某个包中的一个模块，而你试图以脚本模式执行，但是 这种模式不支持相对导入 。
如果你想在自己的代码中使用这个模块，那么你必须将其添加至Python的导入检索路径（import search path）。最简单的做法如下：
import syssys.path.append('/path/to/folder/containing/my_package')import my_package
注意，你需要添加的是 my_package 的上一层文件夹路径，而不是 my_package 本身。原因是 my_package 就是我们想要使用的包，所以如果你添加它的路径，那么将无法使用这个包。
我们接下来谈谈可选导入。
可选导入（Optional imports）
如果你希望优先使用某个模块或包，但是同时也想在没有这个模块或包的情况下有备选，你就可以使用可选导入这种方式。这样做可以导入支持某个软件的多种版本或者实现性能提升。以 github2包 中的代码为例：
try:
# For Python 3
from http.client import responsesexcept ImportError: # For Python 2.5-2.7
try:
from httplib import responses # NOQA
except ImportError: # For Python 2.4
from BaseHTTPServer import BaseHTTPRequestHandler as _BHRH
responses = dict([(k, v[0]) for k, v in _BHRH.responses.items()])
lxml 包也有使用可选导入方式：
try:
from urlparse import urljoin
from urllib2 import urlopenexcept ImportError:
# Python 3
from urllib.parse import urljoin
from urllib.request import urlopen
正如以上示例所示， 可选导入的使用很常见，是一个值得掌握的技巧 。
局部导入
当你在局部作用域中导入模块时，你执行的就是局部导入。如果你在Python脚本文件的顶部导入一个模块，那么你就是在将该模块导入至全局作用域，这意味着之后的任何函数或方法都可能访问该模块。例如：
import sys # global scope
def square_root(a):
# This import is into the square_root functions local scope
import math
return math.sqrt(a)
def my_pow(base_num, power):
return math.pow(base_num, power)
if __name__ == '__main__':
print(square_root(49))
print(my_pow(2, 3))
这里，我们将 sys 模块导入至全局作用域，但我们并没有使用这个模块。然后，在 square_root 函数中，我们将 math
模块导入至该函数的局部作用域，这意味着 math 模块只能在 square_root 函数内部使用。如果我们试图在 my_pow 函数中使用
math ，会引发 NameError 。试着执行这个脚本，看看会发生什么。
使用局部作用域的好处之一，是你使用的模块可能需要很长时间才能导入，如果是这样的话，将其放在某个不经常调用的函数中或许更加合理，而不是直接在全局作
用域中导入。老实说，我几乎从没有使用过局部导入，主要是因为如果模块内部到处都有导入语句，会很难分辨出这样做的原因和用途。
根据约定，所有的导入语句都应该位于模块的顶部 。
导入注意事项
在导入模块方面，有几个程序员常犯的错误。这里我们介绍两个。
循环导入（circular imports）
覆盖导入（Shadowed imports，暂时翻译为覆盖导入）
先来看看循环导入。
循环导入
如果你创建两个模块，二者相互导入对方，那么就会出现循环导入。例如：
# a.pyimport b
def a_test():
print("in a_test")
b.b_test()
a_test()
然后在同个文件夹中创建另一个模块，将其命名为 b.py 。
import a
def b_test():
print('In test_b"')
a.a_test()
b_test()
如果你运行任意一个模块，都会引发 AttributeError 。这是因为这两个模块都在试图导入对方。简单来说，模块 a 想要导入模块 b
，但是因为模块 b 也在试图导入模块 a （这时正在执行），模块 a 将无法完成模块 b
的导入。我看过一些解决这个问题的破解方法（hack），但是 一般来说，你应该做的是重构代码，避免发生这种情况 。
覆盖导入
当你创建的模块与标准库中的模块同名时，如果你导入这个模块，就会出现覆盖导入。举个例子，创建一个名叫 math.py 的文件，在其中写入如下代码：
import math
def square_root(number):
return math.sqrt(number)
square_root(72)
现在打开终端，试着运行这个文件，你会得到以下回溯信息（traceback）：
Traceback (most recent call last):
File "math.py", line 1, in <mole>
import math
File "/Users/michael/Desktop/math.py", line 6, in <mole>
square_root(72)
File "/Users/michael/Desktop/math.py", line 4, in square_root
return math.sqrt(number)AttributeError: mole 'math' has no attribute 'sqrt'
这到底是怎么回事？其实，你运行这个文件的时候，Python解释器首先在当前运行脚本所处的的文件夹中查找名叫 math
的模块。在这个例子中，解释器找到了我们正在执行的模块，试图导入它。但是我们的模块中并没有叫 sqrt 的函数或属性，所以就抛出了
AttributeError 。
⑸ python导入模块的方法有哪些
方法一
import modname
模块是指一个可以交互使用，或者从另一Python 程序访问的代码段。只要导入了一个模块，就可以引用它的任何公共的函数、类或属性。模块可以通过这种方法来使用其它模块的功能。
用import语句导入模块，就在当前的名称空间(namespace)建立了一个到该模块的引用.这种引用必须使用全称，也就是说，当使用在被导入模块中定义的函数时，必须包含模块的名字。所以不能只使用 funcname，而应该使用 modname.funcname
方法二
from modname import funcname
from modname import fa, fb, fc
或者
from modname import *
与第1种方法的区别：funcname 被直接导入到本地名字空间去了，所以它可以直接使用，而不需要加上模块名的限定* 表示，该模块的所有公共对象(public objects)都被导入到 当前的名称空间，也就是任何只要不是以”_”开始的东西都会被导入。
modname没有被定义，所以modname.funcname这种方式不起作用。并且，如果funcname如果已经被定义，它会被新版本（该导入模块中的版本）所替代。如果funcname被改成指向其他对象，modname不能不会觉察到。
建议:
1)如果你要经常访问模块的属性和方法，且不想一遍又一遍地敲入模块名，使用 from mole import
2)如果你想要有选择地导入某些属性和方法，而不想要其它的，使用 from mole import
3)如果模块包含的属性和方法与你的某个模块同名，你必须使用import mole来避免名字冲突
4)尽量少用 from mole import * ，因为判定一个特殊的函数或属性是从哪来的有些困难，并且会造成调试和重构都更困难。
方法三
内建函数__import__()
除了前面两种使用import关键字的方法以外，我们还可以使用内建函数 __import__() 来导入 mole。两者的区别是，import 后面跟的必须是一个类型(type)，而__import__() 的参数是一个字符串，这个字符串可能来自配置文件，也可能是某个表达式计算结果。例如：
mymole = __import__ (’mole_name’)
附注:
1)模块的内容都放在一个模块文件中，如 mymole 的内容应该放在PYTHONPATH 目录下的一个mymole.py中，C实现的除外
2)包可以将几个模块名称空间组织起来, 如A.b 就表示在包A中的一个子模块b
可以单独导入某一个子模块，如Python文档中给出的例子
import sound.effects.echo
这样必须使用全称对里面的对象进行引用，如
sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)
还可以使用下面的语句来加载echo子模块
from Sound.Effects import echo
它在没有包前缀的情况下也可以使用， 所以它可以如下方式调用：
echo.echofilter(input, output, delay=0.7, atten=4)
不主张从一个包或模块中用import * 导入所有模块，因为这样的通常会导致可读性很差。
from Package import specific_submole的用法并没有错，实际上这还是推荐的用法，除非导入的模块需要使用其它包中的同名子模块(the importing mole needs to use submoles with the same name from different packages).
综上所述，一般情况应该使用import , 但有几个例外
1)mole文档告诉你要用from-import的
2)导入一个包组件。需要一个包里面的某个子模块，一般用from A.b import c比import A.b.c 更方便 且不会冒混淆的危险.
⑹ 那些Python中的模块
Python的解释环境是很好用，但是如果我们需要编写一个大型的程序的时候，解释环境就完全不够用了。这个时候我们需要将python程序保存在一个文件里。通常这个文件是以.py结尾的。
对于大型的应用程序来说，一个文件可能是不够的，这个时候我们需要在文件中引用其他的文件，这样文件就叫做模块。
模块是一个包含Python定义和语句的文件。文件名就是模块名后跟文件后缀 .py 。在模块内部，模块名可以通过全局变量 __name__ 获得。
还是之前的斐波拉赫数列的例子，我们在fibo.py文件中存放了函数的实现：
编写完毕之后，我们可以在Python的解释环境中导入它：
然后直接使用即可：
常用的函数，我们可以将其赋值给一个变量：
或者，我们在导入的时候，直接给这个模块起个名字：
或者导入模块中的函数：
每个模块都有它自己的私有符号表，该表用作模块中定义的所有函数的全局符号表。因此，模块的作者可以在模块内使用全局变量，而不必担心与用户的全局变量发生意外冲突。
前面我们提到了可以使用import来导入一个模块，并且 __name__ 中保存的是模块的名字。
和java中的main方法一样，如果我们想要在模块中进行一些测试工作，有没有类似java中main方法的写法呢？
先看一个例子：
在模块中，我们需要进行一个判断 __name__ 是不是被赋值为 "__main__"。
我们这样来执行这个模块：
以脚本执行的情况下，模块的 __name__ 属性会被赋值为 __main__ , 这也是例子中为什么要这样写的原因。
看下执行效果：
如果是以模块导入的话，那么将不会被执行：
使用import导入模块的时候，解释器首先会去找该名字的内置模块，如果没找到的话，解释器会从 sys.path变量给出的目录列表里寻找。
sys.path的初始目录包括：
要想查看模块中定义的内容，可以使用dir函数。
上面的例子列出了当前模块中定义的内容，包括变量，模块，函数等。
我们可以给dir加上参数，来获取特定模块的内容：
java中有package的概念，用来隔离程序代码。同样的在Python中也有包。
我们看一个Python中包的例子：
上面我们定义了4个包，分别是sound,sound.formats, sound.effects, sound.filters。
__init__.py 可以是一个空文件，也可以执行包的初始化代码或设置 __all__ 变量。
当导入的时候， python就会在 sys.path 路径中搜索该包。
包的导入有很多种方式，我们可以导入单个模块：
但是这样导入之后，使用的时候必须加载全名：
如果不想加载全名，可以这样导入：
那么就可以这样使用了：
还可以直接导入模块中的方法：
然后这样使用：
如果一个包里面的子包比较多，我们可能会希望使用 * 来一次性导入：
那么如何去控制到底会导入effects的哪一个子包呢？
我们可以在 __init__.py 中定义一个名叫 __all__ 的列表，在这个列表中列出将要导出的子包名，如下所示：
这样from sound.effects import * 将导入 sound 包的三个命名子模块。
如果没有定义 __all__，from sound.effects import * 语句 不会 从包 sound.effects 中导入所有子模块到当前命名空间；它只会导入包 sound.effects。
Import 可以指定相对路径，我们使用 . 来表示当前包， 使用 .. 来表示父包。
如下所示：
⑺ Python其实很简单 第十六章 目录管理
为实现“按名存取”，必须建立文件名与辅存空间中物理地址的对应关系，体现这种对应关系的数据结构称为文件目录。文件目录表目至少要包含文件名、文件的类型、文件的长度、访问权限、建立时间、访问时间和文件存储地址等内容。通过前面一章的介绍，我们已经知道在文件信息中已经包含了文件名、文件类型访问权限等信息，而存储地址的信息则包含在目录信息中。
16.1路径
路径通常用一个字符串来表示，可以按照路径信息定位到一个目录或文件。如：“C:UsersAdministratorPictures1.jpg”这个信息可以非常方便的找到这个图片文件，“C:UsersAdministratorPictures”这个信息可以帮助我们找到更多的图片文件。
这里所说的“路径”和上网时碰到的“地址”含义比较相似，互联网就相当于将个人电脑可以访问的范围扩大了，互联网中的地址也是对应某一个存储空间的路径，按照地址可以访问互联网上的信息，就如同按照路径可以找到计算机中的文件一样。
在Python中，可以导入 os模块 来进行目录操作。
1、获取当前工作目录getcwd()函数
例：
import os
print(os.getcwd())
运行结果：
C:
这个路径是当前Python IDLE所在的地址。
2、获取文件的绝对路径abspath()函数
abspath()函数是os模块的子模块path提供的一个函数。用法举例如下：
import os
print(os.path.abspath(r'test.txt'))
运行结果：
C: est.txt
16.2 目录操作类函数
1、判断目录是否存在exists()函数
exists()函数是os模块的子模块path中的函数。使用方法举例如下：
import os
print(os.path.exists(r'C:UsersAdministratorPictures1.jpeg'))
输出结果：
True
2、创建目录mkdir()函数和makedirs()函数
mkdir()函数和makedirs()函数都是由os模块提供的，下面举例说明用法和区别。
例1：
import os
path='d:test'
if not os.path.exists(path):
os.makedirs(path)
print('该文件目录创建成功！')
如果目录d: est已存在，则不再创建；若不存在，则创建。
例2：
import os
path='d:testtest1test11'
if not os.path.exists(path):
os.makedirs(path)
print('该文件目录创建成功！')
虽然目录d: est已存在，但可以在其下继续创建子目录。上面的代码可以成功地创建d: est est1 est11目录。
mkdir()函数和makedirs()函数用法基本一样，不同之处在于mkdir()函数只能能创建一级目录。
3、删除目录函数rmdir()函数
rmdir()函数是由os模块提供的。
例如：通过上面的例子已经建立了d: est est1 est11目录，现在去删除子目录test11（此子目录为空目录），代码如下：
import os
os.rmdir('d:testtest1test11')
如果要删除的目录非空（其下还包含有文件或文件夹），则不能删除，并且出现Windows文件操作错误的提示（Python是调用操作系统命令完成文件和目录操作的）。譬如d: est目录下含有有子目录，则不能对其进行如下删除操作。
import os
os.rmdir('d:test')
此时，会出现如下错误提示：
Traceback (most recent call last):
File "C:/Users/zym/AppData/Local/Programs/Python/Python39/4.py", line 10, in
os.rmdir('d:test')
OSError: [WinError 145] 目录不是空的。: 'd:test'
4、删除非空目录函数rmtree()函数
rmtree()函数是由Python内置的标准模块shutil提供的，可以删除目录及目录下的文件和子目录。如删除d: est目录及其下的子目录和文件，可用如下代码：
import shutil
shutil.rmtree('d:test')
5、遍历目录walk()函数
walk()函数是由os模块提供的。
语法格式：
os.walk(top[, topdown=True[, onerror=None[, followlinks=False]]])
其中，top是所要遍历的目录的地址；topdown为可选参数，为 True时自上而下遍历 目录，为False时自下而上遍历目录，默认值为True；onerror为可选参数，用于指定异常处理方式，默认为忽略；followlinks为可选参数，如果为 True，则会遍历目录下的快捷方式(linux 下是软连接 symbolic link )实际所指的目录(默认关闭)，如果为 False，则优先遍历 top 的子目录。
该函数的返回值为一个三元组(root,dirs,files)。root 所指的是当前正在遍历的这个文件夹的本身的地址；dirs 是一个 list ，内容是该文件夹中所有的目录的名字(不包括子目录)；files 同样是 list , 内容是该文件夹中所有的文件(不包括子目录)。
例：遍历d: est目录及其子目录下的所有子目录和文件：
d: est目录及其下的子目录和文件
import os
path='d:test'
tups=os.walk(path) # 函数walk()的返回值为三元组
for root,dirs,files in tups: # 遍历这个三元组
for name in dirs: #遍历存放目录值的元组
print('dir：',os.path.join(root,name))
for name in files: #遍历存放文件名值的元组
print('file：',os.path.join(root,name))
运行结果如下：
dir： d: est est1
dir： d: est est1 est11
dir： d: est est1新建文件夹
file： d: est est1新建文本文档.txt
file： d: est est1 est11新建文本文档.txt