python3包、模块、函数与变量作用域（7）

7.1 while循环与使用场景

常见的循环：while循环和for循环
while容易造成死循环

CONDITION = True

while CONDITION :
print(‘I am While’)

死循环输出：I am While
1
2
3
4
5
6
因为CONDITION永远为True，没有被改变过
ctrl + c 结束死循环

counter = 0

while counter :
counter += 1
print(counter)
1
2
3
4
5
没有打印出任何结果，因为counter = 0，0就是False，所以不会打印出结果
现在把counter改成1

counter = 1

while counter :
counter += 1
print(counter)
1
2
3
4
5
打印的结果会一直刷屏，ctrl + c 结束循环
无限循环是while错误的用法，改成正确的用法：

counter = 1

while counter <= 10 :
counter += 1
print(counter)
1
2
3
4
5
打印出从2到11，这才是while正确的使用方法

如何避免while出现死循环？
首先while后面的条件判断语句不能是常量，如果是常量，条件判断的结果是永远不会改变的，如果想让while运行的次数是有限的，那么在while内部的代码块里面就必须要有能够影响条件判断的语句，在上式中的 counter += 1就是影响条件判断结果的语句，这样就能避免出现死循环；
while除了可以单独使用之外，还可以和 if 一样，和else结合使用，在上面的事例中，如果不加 else，一旦 counter >10 ，整个程序就结束了，在 counter >10，整个程序结束的时候，打印出一个结束的标志EOF，代码如下：

counter = 1

while counter <= 10 :
counter += 1
print(counter)
else:
print(‘EOF’) #while结束后会执行else
1
2
3
4
5
6
7
结果打印出从2到11，还有一个EOF，else的作用就是当 while 后面的条件语句的返回结果是 False 的时候，将执行 else 分支后面的代码块。
while 的使用场景是有一个目标，当达到目标的时候，while 就结束了。递归情况下比较适合用while ，其他情况下建议用 for 。

7.2 for与for-else循环

for主要是用来遍历/循环 序列或者集合、字典，凡是可以表示组概念的python类型都可以用 for 循环来遍历；
对应于其他语言中的for each
事例：

a = [‘apple’,‘orange’,‘banana’,‘grape’]
for x in a:
print(x) #x遍历到列表中哪个元素就输出哪个元素

运行结果是依次打印出了apple orange banana grape
1
2
3
4
5
代码块中还可以嵌套代码块：

a = [[‘apple’,‘orange’,‘banana’,‘grape’],(1,2,3)]
for x in a:
for y in x:
print(y) #打印出列表中所有元素

运行结果是依次打印出了apple orange banana grape 1 2 3
1
2
3
4
5
6
理论上来说，for 循环可以无限极的嵌套，默认情况下， print 打印出的元素都是以列的形式展示出来的，如果想每个元素都在一行打印出来，可以在 print 后面加一个 end=’ ’

a = [[‘apple’,‘orange’,‘banana’,‘grape’],(1,2,3)]
for x in a:
for y in x:
print(y,end =’’) #一横行打印
1
2
3
4
for 也可以和 else 搭配使用

a = [[‘apple’,‘orange’,‘banana’,‘grape’],(1,2,3)]
for x in a:
for y in x:
print(y)
else:
print(‘fruit is gone’)
1
2
3
4
5
6
运行结果是遍历打印出列表中的所有元素后，最末尾打印出了 fruit is gone
当列表中的所有元素都被遍历完之后，else 就会被执行

利用break强行终止循环

a = [1,2,3]
for x in a:
if x == 2:
break
print(x)

运行结果是1
1
2
3
4
5
6
7
利用continue跳过某些字符

a = [1,2,3]
for x in a:
if x == 2:
continue
print(x)

运行结果是1 3
1
2
3
4
5
6
7
利用break强行终止的for循环不会继续执行后面的else语句，而continue会继续执行else
用break：

a = [1,2,3]
for x in a:
if x == 2:
break
print(x)
else:
print(‘EOF’) #此句不执行

运行结果是1
1
2
3
4
5
6
7
8
9
用continue：

a = [1,2,3]
for x in a:
if x == 2:
continue
print(x)
else:
print(‘EOF’) #此句执行

运行结果是1 3 EOF
1
2
3
4
5
6
7
8
9
循环二维数组的跳出

a = [[‘apple’,‘orange’,‘banana’,‘grape’],(1,2,3)]
for x in a:
for y in x:
if y == ‘orange’:
break #只跳出了列表内部循环，元组的循环继续执行
print(y)
else:
print(‘fruit is gone’) #break跳出的是里面的for循环，和else配对的是外面的for循环

运行结果是apple 1 2 3 fruit is gone
1
2
3
4
5
6
7
8
9
10
7.3 for 与 range

利用range()打印0-9

for x in range(0,10):
print(x)
1
2
range(首，跨度，步长)打印0，2，4，6，8

for x in range(0,10,2): #递增输出
print(x,end = ’ | ')

运行结果是：0 | 2 | 4 | 6 | 8 |
1
2
3
4
递减的等差数列：

for x in range(10,0,-2): #递减输出
print(x,end = ’ | ')

运行结果是：10 | 8 | 6 | 4 | 2 |
1
2
3
4
7.4 新篇章导言

打印出序列中相间隔的元素
a = [1,2,3,4,5,6,7,8]

for i in range(0,len(a),2): #步长是2
print(a[i],end = ’ | ')

运行结果是：1 | 3 | 5 | 7 |
1
2
3
4
原理是利用range函数生成了一个等差数列，把数列作为a列表的下标，依次把a里面的每个间隔元素全部取出来
python中有比for循环更好的方式，那就是序列的切片；

a = [1,2,3,4,5,6,7,8]
b = a[0:len(a):2]
print(b)

运行结果是：[1,3,5,7]
1
2
3
4
5
会写代码，非常容易，因为这只考验程序员的逻辑能力
但写出高性能、封装性（可复用）的代码就比较难，因为这不仅考验人的逻辑能力还考验抽象能力

7.5 Python工程的组织结构：包、模块儿、类

最顶级的组织结构：包(文件夹)
第二个层级：模块(文件)
第三个层级：类
第四个层级：函数、变量(不属于组织结构，是类本身的特性)

一个包下面可以包含很多模块
一个模块下面可以包含很多类
在python里面，模块的物理的表现就是我们实际看到的，就是一个.py文件；
模块下面并不是只能写类，还可以写函数、变量及业务逻辑，但是不推荐，最好是用类把函数、变量及业务逻辑组织起来。
包和模块我们可以简单的理解成文件夹和文件，但不代表包和模块就是文件夹和文件，只不过是在物理的表现上，像是一个文件夹和文件。

7.6 Python包与模块的名字

区分不同包的同名模块：包名.模块名
形成的模块的路径叫做命名空间

一个包下面可以有子包，模块可以和包平级

普通文件夹想要变成包必须要有__init__.py文件
init.py本身也是一个模块，可以不写内容只是标注包
特殊的，init.py模块的名字就是包名

7.7 import导入模块

对于重复的定义可以从其他模块里引用，不需要重复编写。
利用 import 模块名 导入

#test1.c1

a = 1

#test1.c2
import c1 #导入c1
print(c1.a)
运行结果：1
1
2
3
4
5
6
python是解释型语言，要先定义后使用

被导入模块在子包下面，要加上命名空间

#test1.t.c1
a = 1

#test1.c2
import t.c1
print(t.c1.a)

运行结果：1
1
2
3
4
5
6
7
8
import导入的总是模块，不能直接导入模块下面的变量，需要用模块名.变量名的方法引用

可以用as简化书写

#test1.c1
a = 1

#test1.c2
import c1 as m
print(m.a)

运行结果：1
1
2
3
4
5
6
7
8
不用as简写的优点是可以一眼看出属于哪个模块

7.8 from import 导入变量

#test1.c2
from c1 import a
print(a)

运行结果：1
1
2
3
4
5
from import 与 import 的区别：
导入的类型不同 import 导入的是模块，from import导入的是具体的变量
因为from import导入的是具体的变量，所以就不需要在变量的前面再加命名空间了。

也可以from 包 import 模块
引用时用 模块.变量，与from区别就不大了
如：

#test1.c2
from t import c1
print(c1.a)

运行结果：1
1
2
3
4
5
引用大量变量时使用 * ：

#test1.c1
a = 1
b = 2
c = 3
d = 4

#test1.c2
from c1 import *
print(a)
print(b)
print©
print(d)

运行结果：1 2 3 4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
不推荐过多的使用 * 因为这样会使引用非常的不明确，而且鼠标放到abcd上会提示abcd没有定义。
编译器会提示语法错误，不过会运行成功；
"*"会一次性的把模块下面所有的变量或者函数全部导入进来，但是在实际的编码过程中不太可能在引入的时候需要全部的变量，那么就需要我们控制 * 的行为，让 * 导入的时候只导入我们指定的变量。

#test1.c1
all = [‘a’,‘c’] #用内置变量__all__来控制 * 的选择范围
a = 1
b = 2
c = 3
d = 4

#test1.c2
from c1 import *
print(a)
print©
print(d) #d没有被打印，报错

运行结果：1 3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
7.9 init.py 的用法

隐藏__pycache__文件夹
文件→首选项→设置→搜索files.exclu，添加**/pycache，保存

代码换行：在上一行末尾加上\或者加上括号利用括号的特性换行，推荐使用括号换行

from c6 import a,b,
c
print(a)

from c6 import (a,b,
c)
print(a)
1
2
3
4
5
6
7
包下面都有__init__.py文件，若没有就不是包，而是一个普通的文件夹
init.py文件的作用：
当包被导入时，init.py会首先自动被执行

#t.init.py
a = ‘This is a init.py file’
print(a)

#c11.py
import t #导入包t，t里面的__init__.py文件就会被自动执行

运行结果：This is a init.py file
1
2
3
4
5
6
7
8
假如不导入包，而是导入包里面模块的某个变量，init文件依旧会自动运行

#t.c7.py
all = [‘a’,‘c’]
a = 2
c = 3
d = 4

#c12.py
from t.c7 import a

运行结果：This is a init.py file
1
2
3
4
5
6
7
8
9
10
结论：无论是导入包还是包下面的某个模块的变量，都会自动运行__init__.py文件

init.py的应用场景：

#t.init.py
all = [‘c7’] #初始化*，标明哪些模块被导出

#t.c7.py
all = [‘a’,‘c’]
a = 2
c = 3
d = 4

#t.c8.py
e = 2
f = 3
g = 4

#c11.py
from t import * #* 表示导入 t 包里的所有模块
print(c7.a) #c7在init中被定义，可引用
print(c8.e) #c8在init中未定义，不可引用

运行结果是2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
init重要的作用：批量导入库

#t.init.py
import sys #批量导入库，内置标准库
import datetime
import io

#c13.py
import t
print(t.sys.path) #在这里插入代码片
1
2
3
4
5
6
7
8
7.10 包与模块的几个常见错误

包和模块是不会被重复的导入的，只会执行一次
避免循环导入，不要形成闭环（多个模块之间形成闭环）
导入模块的时候会执行模块里所有的代码

7.11 模块内置变量

#t.c14.py
a = 2
c = 3
infos = dir() #打印当前模块内所有变量
print(infos)
运行结果：[‘annotations’, ‘builtins’, ‘cached’, ‘doc’, ‘file’, ‘loader’, ‘name’, ‘package’, ‘spec’,‘a’,’]

#t.c9.py
‘’’
This is a c9 doc #注释
‘’’
print(‘name:’ + name) # + 把他们连接在一起，
print(‘package:’ + package)
print(‘doc:’ + doc) #doc指的是模块的注释
print(‘file:’ + file)

#c15.py
import t.c9
c15.py运行结果：
name:t.c9 #c9模块的完整命名
package:t #c9模块的包
doc:
This is a c9 doc #c9模块的注释
file:D:\install\python\t\c9.py #c9模块在系统中的物理路径
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
7.12 入口文件和普通模块内置变量的区别

#c15.py
import t.c9
print(‘package:’ + package )
print(‘name:’ + name)
print(‘doc:’ + doc)
print(‘file:’ + file)

运行结果：
name:t.c9
package:t
doc:
This is a c9 doc
file:D:\install\python\t\c9.py
c9运行成功，c15运行失败，因为c15不属于任何包
1
2
3
4
5
6
7
8
9
10
11
12
13
14
修改后：

#c15.py
import t.c9
print(‘package:’ + (package or ‘当前模块不属于任何包’)) #因为+的优先级高于or，所以加()
print(‘name:’ + name)
print(‘doc:’ + doc)
print(‘file:’ + file)
运行结果：
name:t.c9
package:t
doc:
This is a c9 doc
file:D:\install\python\t\c9.py
package:当前模块不属于任何包
name:main #入口文件中__name__会被强制修改为__main__
1
2
3
4
5
6
7
8
9
10
11
12
13
14
再次修改：

#c15.py
import t.c9
print('c15~)
print(‘package:’ + (package or ‘当前模块不属于任何包’))
print(‘name:’ + name)
print(‘doc:’ +( doc__or ‘当前模块没有文档注释’))
print(‘file:’ + file)
运行结果：
name:t.c9
package:t
doc:
This is a c9 doc
file:D:\install\python\t\c9.py
c15~
package:当前模块不属于任何包
name:main
doc：当前模块没有文档注释
file：c15.py #入口文件中路径不同 ，和执行python命令所在目录是有关系的
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
差异：
导入的模块：有package name是模块名字 file是完整的系统路径
入口文件：没有package name是__main file是py文件的名字

7.13 __name__的经典应用

dir()若不传参数可以打印当前模块所有可见的变量，传参显示特定的变量

#c16.py

import sys
infos = dir(sys)
print(infos)
1
2
3
4
5
运行结果是打印出很多变量

#c17.py

if name == ‘main’: #内置变量
print(‘This is app’)

print('This is a module')

运行结果是：This is app
This is a module

#c18.py

import c17
运行结果是：This is a module
1
2
3
4
5
6
7
8
9
10
11
12
13
make a script both importable and executable:
翻译：让你的python脚本既可以作为一个普通的模块提供给其他的应用程序调用，
也可以让他自己成为一个可执行的文件

cmd中 python -m 命名空间.模块 可以把入口文件当作模块来运行
作为普通模块必须要有包，可执行文件没有包

7.14 相对导入和绝对导入 一

有一个主入口文件。
顶级包和可执行文件在同一级。
绝对导入：从顶级包开始往下导入
相对导入：. 同级目录 …上级目录 …上上级目录
在相对路径中应使用from import 不能使用 import
不能在入口文件中使用相对路径

7.15 相对导入和绝对导入 二

相对导入不能超过顶级包。
入口不能使用相对路径导入，相对路径根据__name__定位，由于入口文件被强制改成了__main__所以不能使用。
在入口文件中可以使用绝对路径导入。
若想在入口文件使用相对导入，可以把入口文件当做一个模块来使用，回到PYTHON的上一级，即

用python -m PYTHON.main来执行。