Python3学习笔记1112- 数据结构/深入模块

相似文件 换一批

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

送您一个全额奖学金名额~ !

立即领取

感谢您参与论坛问题回答

经管之家送您两个论坛币！

+2 论坛币

第11-12发，重新整理数据结构，并深入介绍python模块：
[url=]Python3学习笔记12- Python3 模块 ...[/url]
[url=][url=]Python3学习笔记11- 数据结构.tx ...[/url][/url]

扫码加我 拉你入群

请注明：姓名-公司-职位

以便审核进群资格，未注明则拒绝

分享0 收藏0 回帖

关键词：数据结构 学习笔记

# 2018.05.19
# by pengxw

# Python3 数据结构

# 本章节我们主要结合前面所学的知识点来介绍Python数据结构。

# =============================================================================
# 列表
# =============================================================================
#
#
# Python中列表是可变的，这是它区别于字符串和元组的最重要的特点，一句话概括即：列表可以修改，而字符串和元组不能。
# 以下是 Python 中列表的方法：
# 方法        描述
# list.append(x)        把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]。
# list.extend(L)        通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):] = L。
# list.insert(i, x)        在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x) 。
# list.remove(x)        删除列表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个错误。
# list.pop([i])        从列表的指定位置移除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。元素随即从列表中被移除。（方法中 i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在 Python 库参考手册中遇到这样的标记。）
# list.clear()        移除列表中的所有项，等于del a[:]。
# list.index(x)        返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。
# list.count(x)        返回 x 在列表中出现的次数。
# list.sort()        对列表中的元素进行排序。
# list.reverse()        倒排列表中的元素。
# list.copy()        返回列表的浅复制，等于a[:]。
temp_list = [1,2,3,4,5,4,3,2,1,0]
# 对元素计数
print(temp_list.count(0), temp_list.count(2))
# 在index=3的位置插入元素-5
temp_list.insert(3,-5)
# 在列表末尾添加元素 -10
temp_list.append(-10)
# 输出元素第一次出现的索引index
temp_list.index(4)
# 移除第一次出现的该元素
temp_list.remove(2)
# 对元素倒排序
temp_list.reverse()
# 对元素排序
temp_list.sort()

# 将列表当做堆栈使用
# 列表方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素最后一个被释放（后进先出）。
# 用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。

stack = [3,4,5]
stack.append(6)
stack.append(7)
stack.pop()
stack.pop()

# 将列表当作队列使用
# 也可以把列表当做队列用，只是在队列里第一加入的元素，第一个取出来；但是拿列表用作这样的目的效率不高。
# 在列表的最后添加或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快（因为所有其他的元素都得一个一个地移动）。
# 导入deque函数
from collections import deque

stack = deque([3,4,5]) # deque()里参数为迭代器
stack.append(6)
stack.append(7)
stack.popleft() # 列表对象无popleft函数


# 列表推导式
# 列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素，
# 用其获得的结果作为生成新列表的元素，或者根据确定的判定条件创建子序列。
# 每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。
# 返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组，就必须使用括号。
# 这里我们将列表中每个数值乘三，获得一个新的列表
vec = [2, 4, 6]
[3*x for x in vec]
# Out[31]: [6, 12, 18]
[[x, x**2] for x in vec]
# Out[32]: [[2, 4], [4, 16], [6, 36]]

# 这里我们对序列里每一个元素逐个调用某方法：
freshfruit = [' banana', ' loganberry', 'passion fruit ']
[weapon.strip() for weapon in freshfruit]
# ['banana', 'loganberry', 'passion fruit']

# 我们可以用 if 子句作为过滤器
[3*x for x in vec if x>3]
# Out[37]: [12, 18]

# 以下是一些关于循环和其它技巧的演示
vec1 = [2, 4, 6]
vec2 = [3, 5, 7]
[x*y for x in vec1 for y in vec2]
# Out[38]: [6, 10, 14, 12, 20, 28, 18, 30, 42]
[vec1[i]*vec2[i] for i in range(len(vec1))]
# Out[39]: [6, 20, 42]

# 列表推导式可以使用复杂表达式或嵌套函数
[str(round(355/113, i)) for i in range(1, 6)]
# Out[40]: ['3.1', '3.14', '3.142', '3.1416', '3.14159']

# 列表推导式的执行顺序：各语句之间是嵌套关系，左边第二个语句是最外层，依次往右进一层，左边#第一条语句是最后一层。
[x*y for x in range(1,5) if x>3 for y in range(-2,3) if y<2]
# Out[48]: [-8, -4, 0, 4]
# 他的执行顺序是
for x in range(1,5):
    if x >3:
        for y in range(-2,3):
            if y<2:
                x*y
                print(x, y, x*y)
                               
matrix = [[1,2,3,4],
          [5,6,7,8],
          [9,10,11,12]]

# 嵌套列表解析
# Python的列表还可以嵌套。
# 以下实例展示了3X4的矩阵列表
[[row[i] for row in matrix] for i in range(4)]
# Out[11]: [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
for row in matrix:
    print(row)
# [1, 2, 3, 4]
# [5, 6, 7, 8]
# [9, 10, 11, 12]

# 另外一种实现方法：
transposed = []
for i in range(4):
    # the following 3 lines implement the nested listcomp
    transposed_row = []
    for row in matrix:
        transposed_row.append(row[i])
    transposed.append(transposed_row)

transposed
# Out[15]: [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

# del 语句
# 使用 del 语句可以从一个列表中依索引而不是值来删除一个元素。这与使用 pop() 返回一个值不同。
# 可以用 del 语句从列表中删除一个切割，或清空整个列表（我们以前介绍的方法是给该切割赋一个空列表）。例如：
vec1 = [2, 4, 6, 8, 10]
del vec1[0]
vec1
del vec1[2:3]
vec1
# [4, 6, 10]
del vec1[:]
vec1  
# []
# 也可以用 del 删除实体变量：
del vec1


# =============================================================================
# 元组和序列
# =============================================================================
#

# 元组由若干逗号分隔的值组成,元组在输出时总是有括号的，以便于正确表达嵌套结构。
# 在输入时可能有或没有括号， 不过括号通常是必须的（如果元组是更大的表达式的一部分）。
t = 345, 678, 123, 'hello'
t[0]
# 345
u = t,(1,2,3,4)
u
# ((345, 678, 123, 'hello'), (1, 2, 3, 4))

# 元组不可变，若元组的成员可变类型，则成员可编辑。
a, b, c = [1,2,3,4], [5,6,7,8], [9,10,11,12]
t = a, b, c
print(t)
# ([1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12])
del b[1:3]
print(t)
# ([1, 2, 3, 4], [5, 8], [9, 10, 11, 12])


# =============================================================================
# 集合
# =============================================================================
#

# 集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。
# 可以用大括号({})创建集合。注意：如果要创建一个空集合，你必须用 set() 而不是 {} ；后者创建一个空的字典
# ，下一节我们会介绍这个数据结构。以下是一个简单的演示：
basket = {'apple', 'orange', 'apple', 'pear'}
print(basket)
# {'apple', 'pear', 'orange'}
'orange' in basket

a = set('apple')
b = set('pear')
a # a中唯一的字母
# Out[29]: {'a', 'e', 'l', 'p'}
b # b中唯一的字母
# Out[30]: {'a', 'e', 'p', 'r'}
a - b # 在a中不在b中
# Out[31]: {'l'}
a | b # 在a或b中
# Out[32]: {'a', 'e', 'l', 'p', 'r'}
a & b # 在a且在b中
# Out[33]: {'a', 'e', 'p'}
a ^ b # 异或，在a或b的字母但不同时在a和b中
# Out[34]: {'l', 'r'}

# 集合也支持推导式,元组不支持：
a = {x for x in 'shawn' if x not in 'abc'}
a
# Out[36]: {'h', 'n', 's', 'w'}


# =============================================================================
# 字典
# =============================================================================
#

# 另一个非常有用的 Python 内建数据类型是字典。
# 序列是以连续的整数为索引，与此不同的是，字典以关键字为索引，关键字可以是任意不可变类型，通常用字符串或数值。
# 理解字典的最佳方式是把它看做无序的键=>值对集合。在同一个字典之内，关键字必须是互不相同。
# 一对大括号创建一个空的字典：{}。
contactor = {'name':'shawn', 'age':27, 'gender':'male'}
list(contactor.keys())
# Out[49]: ['name', 'age', 'gender']
{x: x**2 for x in (1,2,3,4,5)}
# Out[50]: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
# 构造函数 dict() 直接从键值对元组列表中构建字典。如果有固定的模式，列表推导式指定特定的键值对：
dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
# Out[51]: {'guido': 4127, 'jack': 4098, 'sape': 4139}
# 如果关键字只是简单的字符串，使用关键字参数指定键值对有时候更方便：
dict(sape=4139, guido=4127, jack=4098)
# Out[52]: {'guido': 4127, 'jack': 4098, 'sape': 4139}


# =============================================================================
# 遍历技巧
# =============================================================================
#
# 在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来：
dict1 = dict(sape=4139, guido=4127, jack=4098)
for k, v in dict1.items():
    print(k, v)

# sape 4139
# guido 4127
# jack 4098

# 在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到：
for k, v in enumerate(['shawn', 27, 'male']):
    print(k, v)
       
# 0 shawn
# 1 27
# 2 male

# 同时遍历两个或更多的序列，可以使用 zip() 组合：
questions = ['name', 'favorite color', 'gender']
answers = ['shawn', 'blue', 'male']
for q, a in zip(questions, answers):
    print('What is your {0}? It is {1}.'.format(q,a))

# What is your name? It is shawn.
# What is your favorite color? It is blue.
# What is your gender? It is male.

# 有多个列表需要遍历时，需要zip，除了用'{0}{1}'.format(q,a)的方法，还可以使用%s方法（两者效果一样一样的）
questions = ['name', 'favorite color', 'gender']
answers = ['shawn', 'blue', 'male']
for q, a in zip(questions, answers):
    print('What is your {0}? It is {1}.'.format(q,a))
    print('what is your %s? it is %s.' %(q,a))
# What is your name? It is shawn.
# what is your name? it is shawn.
# What is your favorite color? It is blue.
# what is your favorite color? it is blue.
# What is your gender? It is male.
# what is your gender? it is male.
       
# 要反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数：
for i in reversed(range(1, 10, 2)):
    print(i)

# 9
# 7
# 5
# 3
# 1

# 要按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值：
basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
for f in sorted(set(basket)):
    print(f)
# apple
# banana
# orange
# pear
print(basket)
# ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']

# 2018.05.21
# by pengxw


# Python3 模块
# 在前面的几个章节中我们脚本上是用 python 解释器来编程，如果你从 Python 解释器退出再进入，那么你定义的所有的方法和变量就都消失了。
# 为此 Python 提供了一个办法，把这些定义存放在文件中，为一些脚本或者交互式的解释器实例使用，这个文件被称为模块。
# 模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。
# 这也是使用 python 标准库的方法。
import sys
print('\n\nPython 路径为：', sys.path, '\n')
# Python 路径为： ['', 'D:\\wj48484\\Anaconda\\python36.zip', 'D:\\wj48484\\Anaconda\\DLLs', 'D:\\wj48484\\Anaconda\\lib', 'D:\\wj48484\\Anaconda', 'D:\\wj48484\\Anaconda\\lib\\site-packages', 'D:\\wj48484\\Anaconda\\lib\\site-packages\\Babel-2.5.0-py3.6.egg', 'D:\\wj48484\\Anaconda\\lib\\site-packages\\win32', 'D:\\wj48484\\Anaconda\\lib\\site-packages\\win32\\lib', 'D:\\wj48484\\Anaconda\\lib\\site-packages\\Pythonwin', 'D:\\wj48484\\Anaconda\\lib\\site-packages\\IPython\\extensions', 'C:\\Users\\wj48484\\.ipython']

# 1、import sys 引入 python 标准库中的 sys.py 模块；这是引入某一模块的方法。
# 2、sys.path 包含了一个 Python 解释器自动查找所需模块的路径的列表。

# import 语句
# 想使用 Python 源文件，只需在另一个源文件里执行 import 语句，语法如下：
# import module1[, module2[,... moduleN]

# 当解释器遇到 import 语句，如果模块在当前的搜索路径就会被导入。
# 搜索路径是一个解释器会先进行搜索的所有目录的列表。如想要导入模块 support，需要把命令放在脚本的顶端：
# support.py 文件代码为：

# Filename: support.py

def print_func( par ):
    print ("Hello : ", par)
    return

# 将上述pythoon代码保存在上述路径的某一个路径，也可以直接保存在默认路径，后缀为.py
# 在其他模块导入该模块
import support
support.print_func("Shawn") # 调用模块函数
# Hello :  Shawn

# 一个模块只会被导入一次，不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。
# 当我们使用import语句的时候，Python解释器是怎样找到对应的文件的呢？
# 这就涉及到Python的搜索路径，搜索路径是由一系列目录名组成的，Python解释器就依次从这些目录中去寻找所引入的模块。
# 这看起来很像环境变量，事实上，也可以通过定义环境变量的方式来确定搜索路径。
# 搜索路径是在Python编译或安装的时候确定的，安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量，
# 做一个简单的实验，在交互式解释器中，输入以下代码
import sys
sys.path

#['', 'D:\\wj48484\\Anaconda\\python36.zip', 'D:\\wj48484\\Anaconda\\DLLs', 'D:\\wj48484\\Anaconda\\lib', 'D:\\wj48484\\Anaconda', 'D:\\wj48484\\Anaconda\\lib\\site-packages', 'D:\\wj48484\\Anaconda\\lib\\site-packages\\Babel-2.5.0-py3.6.egg', 'D:\\wj48484\\Anaconda\\lib\\site-packages\\win32', 'D:\\wj48484\\Anaconda\\lib\\site-packages\\win32\\lib', 'D:\\wj48484\\Anaconda\\lib\\site-packages\\Pythonwin', 'D:\\wj48484\\Anaconda\\lib\\site-packages\\IPython\\extensions', 'C:\\Users\\wj48484\\.ipython']

# sys.path 输出是一个列表，其中第一项是空串''，代表当前目录（若是从一个脚本中打印出来的话，可以更清楚地看出是哪个目录），
# 亦即我们执行python解释器的目录（对于脚本的话就是运行的脚本所在的目录）。
# 因此若像我一样在当前目录下存在与要引入模块同名的文件，就会把要引入的模块屏蔽掉。
# 了解了搜索路径的概念，就可以在脚本中修改sys.path来引入一些不在搜索路径中的模块。
# 现在，在解释器的当前目录或者 sys.path 中的一个目录里面来创建一个fibo.py的文件，代码如下

# 斐波那契(fibonacci)数列模块

def fib(n):    # 定义到 n 的斐波那契数列
    a, b = 0, 1
    while b < n:
        print(b, end=' ')
        a, b = b, a+b
    print()

def fib2(n): # 返回到 n 的斐波那契数列
    result = []
    a, b = 0, 1
    while b < n:
        result.append(b)
        a, b = b, a+b
    return result
       
# 然后进入Python解释器，使用下面的命令导入这个模块
import fibo
# 这样做并没有把直接定义在fibo中的函数名称写入到当前符号表里，只是把模块fibo的名字写到了那里。
# 可以使用模块名称来访问函数：
fibo.fib(1000)
# 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
fibo.fib2(100)
# Out[9]: [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
fibo.__name__
# 'fibo'

# 如果你打算经常使用一个函数，你可以把它赋给一个本地的名称：
fib = fibo.fib
fib(500)
# 1 1 2 3 5 8 13 21 34 55 89 144 233 377

# from…import 语句
# Python的from语句让你从模块中导入一个指定的部分到当前命名空间中，语法如下：
# from modname import name1[, name2[, ... nameN]]
# 例如，要导入模块 fibo 的 fib 函数，使用如下语句
from fibo import fib, fib2
fib2(200)
# Out[13]: [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144]
# 这个声明不会把整个fibo模块导入到当前的命名空间中，它只会将fibo里的fib函数引入进来。
# 这种导入的方法不会把被导入的模块的名称放在当前的字符表中（所以在这个例子里面，fibo 这个名称是没有定义的）。

# From…import* 语句
# 把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：
# from modname import *
# 这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。
# 这将把所有的名字都导入进来，但是那些由单一下划线（_）开头的名字不在此例。
# 大多数情况， Python程序员不使用这种方法，因为引入的其它来源的命名，很可能覆盖了已有的定义。


# 深入模块
# 模块除了方法定义，还可以包括可执行的代码。这些代码一般用来初始化这个模块。这些代码只有在第一次被导入时才会被执行。
# 每个模块有各自独立的符号表，在模块内部为所有的函数当作全局符号表来使用。
# 所以，模块的作者可以放心大胆的在模块内部使用这些全局变量，而不用担心把其他用户的全局变量搞花。
# 从另一个方面，当你确实知道你在做什么的话，你也可以通过 modname.itemname 这样的表示法来访问模块内的函数。
# 模块是可以导入其他模块的。在一个模块（或者脚本，或者其他地方）的最前面使用 import 来导入一个模块，当然这只是一个惯例，
# 而不是强制的。被导入的模块的名称将被放入当前操作的模块的符号表中。


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

# Filename: using_name.py

if __name__ == '__main__':
   print('程序自身在运行')
else:
   print('我来自另一模块')
   
import using_name
# 我来自另一个模块！

# 说明： 每个模块都有一个__name__属性，当其值是'__main__'时，表明该模块自身在运行，否则是被引入。
# 说明：__name__ 与 __main__ 底下是双下划线， _ _ 是这样去掉中间的那个空格。


# dir() 函数
# 内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回
import sys
dir(sys)
dir() # 如果没有给定参数，那么 dir() 函数会罗列出当前定义的所有名称:


# 包
# 包是一种管理 Python 模块命名空间的形式，采用"点模块名称"。
# 比如一个模块的名称是 A.B， 那么他表示一个包 A中的子模块 B 。
# 就好像使用模块的时候，你不用担心不同模块之间的全局变量相互影响一样，
# 采用点模块名称这种形式也不用担心不同库之间的模块重名的情况。
# 这样不同的作者都可以提供 NumPy 模块，或者是 Python 图形库。
# 不妨假设你想设计一套统一处理声音文件和数据的模块（或者称之为一个"包"）。
# 现存很多种不同的音频文件格式（基本上都是通过后缀名区分的，例如： .wav，:file:.aiff，:file:.au，），
# 所以你需要有一组不断增加的模块，用来在不同的格式之间转换。
# 并且针对这些音频数据，还有很多不同的操作（比如混音，添加回声，增加均衡器功能，创建人造立体声效果），
# 所以你还需要一组怎么也写不完的模块来处理这些操作。
# 这里给出了一种可能的包结构（在分层的文件系统中）:

sound/                          顶层包
      __init__.py               初始化 sound 包
      formats/                  文件格式转换子包
              __init__.py
              wavread.py
              wavwrite.py
              aiffread.py
              aiffwrite.py
              auread.py
              auwrite.py
              ...
      effects/                  声音效果子包
              __init__.py
              echo.py
              surround.py
              reverse.py
              ...
      filters/                  filters 子包
              __init__.py
              equalizer.py
              vocoder.py
              karaoke.py
              ...

# 在导入一个包的时候，Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。
# 目录只有包含一个叫做 __init__.py 的文件才会被认作是一个包，主要是为了避免一些滥俗的名字
# （比如叫做 string）不小心的影响搜索路径中的有效模块。
# 最简单的情况，放一个空的 :file:__init__.py就可以了。当然这个文件中也可以包含一些初始化代码或者为
# （将在后面介绍的） __all__变量赋值。
# 用户可以每次只导入一个包里面的特定模块，比如:
import sound.effects.echo
# 这将会导入子模块:sound.effects.echo。 他必须使用全名去访问:
sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)

# 还有一种导入子模块的方法是:
from sound.effects import echo
# 这同样会导入子模块: echo，并且他不需要那些冗长的前缀，所以他可以这样使用:
echo.echofilter(input, output, delay=0.7, atten=4)

# 还有一种变化就是直接导入一个函数或者变量:
from sound.effects.echo import echofilter
# 同样的，这种方法会导入子模块: echo，并且可以直接使用他的 echofilter() 函数:
echofilter(input, output, delay=0.7, atten=4)

# 注意当使用from package import item这种形式的时候，对应的item既可以是包里面的子模块（子包），
# 或者包里面定义的其他名称，比如函数，类或者变量。
# import语法会首先把item当作一个包定义的名称，如果没找到，再试图按照一个模块去导入。如果还没找到，
# 恭喜，一个:exc:ImportError 异常被抛出了。
# 反之，如果使用形如import item.subitem.subsubitem这种导入形式，除了最后一项，都必须是包，
# 而最后一项则可以是模块或者是包，但是不可以是类，函数或者变量的名字。

# 从一个包中导入*
# 设想一下，如果我们使用 from sound.effects import *会发生什么？
# Python 会进入文件系统，找到这个包里面所有的子模块，一个一个的把它们都导入进来。
# 但是很不幸，这个方法在 Windows平台上工作的就不是非常好，因为Windows是一个大小写不区分的系统。
# 在这类平台上，没有人敢担保一个叫做 ECHO.py 的文件导入为模块 echo 还是 Echo 甚至 ECHO。
# （例如，Windows 95就很讨厌的把每一个文件的首字母大写显示）而且 DOS 的 8+3 命名规则对长模块名称的处理会把问题搞得更纠结。
# 为了解决这个问题，只能烦劳包作者提供一个精确的包的索引了。
# 导入语句遵循如下规则：如果包定义文件 __init__.py 存在一个叫做 __all__ 的列表变量，
# 那么在使用 from package import * 的时候就把这个列表中的所有名字作为包内容导入。
# 作为包的作者，可别忘了在更新包之后保证 __all__ 也更新了啊。你说我就不这么做，我就不使用导入*这种用法，
# 好吧，没问题，谁让你是老板呢。这里有一个例子，在:file:sounds/effects/__init__.py中包含如下代码:
__all__ = ["echo", "surround", "reverse"]

# 这表示当你使用from sound.effects import *这种用法时，你只会导入包里面这三个子模块。
# 如果 __all__ 真的没有定义，那么使用from sound.effects import *这种语法的时候，就不会导入包 sound.effects 里的任何子模块。
# 他只是把包sound.effects和它里面定义的所有内容导入进来（可能运行__init__.py里定义的初始化代码）。
# 这会把 __init__.py 里面定义的所有名字导入进来。并且他不会破坏掉我们在这句话之前导入的所有明确指定的模块。看下这部分代码:

import sound.effects.echo
import sound.effects.surround
from sound.effects import *
# 这个例子中，在执行from...import前，包sound.effects中的echo和surround模块都被导入到当前的命名空间中了。
# （当然如果定义了__all__就更没问题了）
# 通常我们并不主张使用*这种方法来导入模块，因为这种方法经常会导致代码的可读性降低。不过这样倒的确是可以省去不少敲键的功夫，
# 而且一些模块都设计成了只能通过特定的方法导入。
# 记住，使用from Package import specific_submodule这种方法永远不会有错。事实上，这也是推荐的方法。
# 除非是你要导入的子模块有可能和其他包的子模块重名。
# 如果在结构中包是一个子包（比如这个例子中对于包sound来说），而你又想导入兄弟包（同级别的包）你就得使用导入绝对的路径来导入。
# 比如，如果模块sound.filters.vocoder 要使用包sound.effects中的模块echo，你就要写成 from sound.effects import echo。

from . import echo
from .. import formats
from ..filters import equalizer
# 无论是隐式的还是显式的相对导入都是从当前模块开始的。主模块的名字永远是"__main__"，一个Python应用程序的主模块，应当总是使用绝对路径引用。
# 包还提供一个额外的属性__path__。这是一个目录列表，里面每一个包含的目录都有为这个包服务的__init__.py，
# 你得在其他__init__.py被执行前定义哦。可以修改这个变量，用来影响包含在包里面的模块和子包。
# 这个功能并不常用，一般用来扩展包里面的模块。