宝塔面板怎么做自己的网站,wordpress cms列表页,wordpress网站前台打开慢,wordpress企业自适应目录 15#xff0c;Python3 迭代器与生成器15-1 迭代器15-1-1 基础知识15-1-2 迭代器与for循环工作原理 15-2 生成器#xff08;本质就是迭代器#xff09;15-2-1 yield 表达式15-2-2 三元表达式15-2-3 列表生成式15-2-4 其他生成器#xff08;——没有元祖生成式——… 目录 15Python3 迭代器与生成器15-1 迭代器15-1-1 基础知识15-1-2 迭代器与for循环工作原理 15-2 生成器本质就是迭代器15-2-1 yield 表达式15-2-2 三元表达式15-2-3 列表生成式15-2-4 其他生成器——没有元祖生成式——15-2-5 二分法15-2-6 匿名函数与lambdaj 16Python3 函数16-1 定义一个函数16-2 函数调用16-3 参数传递16-4 可更改(mutable)与不可更改(immutable)对象16-5 python 传不可变对象实例16-6 传可变对象实例16-7 函数参数详解16-7-1 位置参数--------关键字参数---------混合使用16-7-2 默认参数------位置参数与默认参数混用16-7-3 可变长度的参数16-7-4 函数的类型提示 17Python3 数据结构17-1 列表17-2 将列表当做堆栈使用17-3 将列表当作队列使用17-4 列表推导式17-5 嵌套列表解析17-6 del 语句17-7 元组和序列17-8 集合17-9 字典17-10 遍历技巧 18Python3 模块18-1 模块18-2 写模块时测试18-3 from xxx import xxx18-4 从一个模块导入所有18-5 sys.path 模块搜索路径优先级18-6 sys.modules 查看内存中的模块18-7 编写规范的模块 15Python3 迭代器与生成器
15-1 迭代器
15-1-1 基础知识
1迭代器迭代取值的工具迭代是重复的过程每一次重复都是基于上次的结果而继续的单纯的重复不是迭代
# 可迭代对象 但凡内置有__iter__()方法的都称之为可迭代对象
# 字符串---列表---元祖---字典---集合---文件操作 都是可迭代对象# 调用可迭代对象下的__iter__方法将其转换为可迭代对象
d {a:1, b:2, c:3}d_iter d.__iter__() # 把字典d转换成了可迭代对象# d_iter.__next__() # 通过__next__()方法可以取值print(d_iter.__next__()) # a
print(d_iter.__next__()) # b
print(d_iter.__next__()) # c# 没值了以后就会报错 抛出异常StopIteration
#-----------------------------------------------
d {a:1, b:2, c:3}
d_iter d.__iter__()
while True:try:print(d_iter.__next__())except StopIteration:break
# 对同一个迭代器对象取值取干净的情况下第二次取值的时候去不了没值只能造新的迭代器15-1-2 迭代器与for循环工作原理
#可迭代对象与迭代器详解#可迭代对象内置有__iter__() 方法对象# 可迭代对象.__iter__(): 得到可迭代对象#迭代器对象内置有__next__() 方法# 迭代器对象.__next__()得到迭代器的下一个值# 迭代器对象.__iter__(): 得到的值迭代器对象的本身调跟没调一个样----------- 为了保证for循环的工作# for循环工作原理d {a:1, b:2, c:3}d_iter d.__iter__()# 1d.__iter__() 方法得到一个跌倒器对象# 2,迭代器对象的__next__()方法拿到返回值将该返回值赋值给k# 3,循环往复步骤2直到抛出异常for循环会捕捉异常并结束循坏for k in d:print(k)# 可迭代器对象不一定是迭代器对象------------迭代器对象一定是可迭代对象# 字符串---列表---元祖---字典---集合只是可迭代对象不是迭代器对象、# 文件操作时迭代器对象也是可迭代对象15-2 生成器本质就是迭代器
# 函数里包含yield,并且调用函数以后就能得到一个可迭代对象
def test():print(第一次)yield 1print(第二次)yield 2print(第三次)yield 3print(第四次)g test()
print(g) # generator object test at 0x0000014C809A27A0
g_iter g.__iter__()
res1 g_iter.__next__() # 第一次
print(res1) # 1
res2 g_iter.__next__() # 第二次
print(res2) # 2
res3 g_iter.__next__() # 第三次
print(res3) # 3 # 补充
len(s) ------- s.__len__()
next(s) ------ s.__next__()
iter(d) ------- d.__iter__()15-2-1 yield 表达式
def person(name):print(%s吃东西啦%name)while True:x yield Noneprint(%s吃东西啦---%s%(name,x))g person(aini)
# next(g) g.send(None)
next(g)
next(g)
# send()方法可以给yield传值
# 不能在第一次运行时用g.send()来传值需要用g.send(None)或者next(g) 来初始化第二次开始可以用g.send(值)来传值
g.send(雪糕) # aini吃东西啦---雪糕
g.send(西瓜) # aini吃东西啦---西瓜15-2-2 三元表达式
x 10
y 20
res x if x y else y
# 格式
条件成立时返回的值 if 条件 else 条件不成立时返回的值15-2-3 列表生成式
l [aini_aaa,dilnur_aaa,donghua_aaa,egon]
res [name for name in l if name.endswith(aaa)]
print(res)# 语法 [结果 for 元素 in 可迭代对象 if 条件]l [aini_aaa,dilnur_aaa,donghua_aaa,egon]
l [name.upper() for name in l]
print(l)l [aini_aaa,dilnur_aaa,donghua_aaa,egon]
l [name.replace(_aaa,) for name in l if name.endswith(_aaa)]
print(l)15-2-4 其他生成器——没有元祖生成式——
### 字典生成器
keys [name,age,gender]
res {key: None for key in keys}
print(res) # {name: None, age: None, gender: None}items [(name,aini),(age,22),(gender,man)]
res {k:v for k,v in items}
print(res)## 集合生成器
keys [name,age,gender]
set1 {key for key in keys}## 没有元祖生成器
g (i for i in range(10) if i % 4 0 ) ## 得到的是一个迭代器#### 统计文件字符个数
with open(aini.txt, modert, encoding utf-8) as f:res sum(len(line) for line in f)print(res)15-2-5 二分法
l [-10,-6,-3,0,1,10,56,134,222,234,532,642,743,852,1431]def search_num(num,list):mid_index len(list) // 2if len(list) 0:print(没找到)return Falseif num list[mid_index]:list list[mid_index 1 :]search_num(num,list)elif num list[mid_index]:list list[:mid_index]search_num(num, list)else:print(找到了 , list[mid_index])search_num(743,l)15-2-6 匿名函数与lambdaj
## 定义
res lambda x,y : xy
## 调用
(lambda x,y : xy)(10,20) # 第一种方法
res(10,20) ## 第二种方法##应用场景
salary {aini:20000,aili:50000,dilnur:15000,hahhaha:42568,fdafdaf:7854
}res max(salary ,key lambda x : salary[x])
print(res)16Python3 函数
函数是组织好的可重复使用的用来实现单一或相关联功能的代码段。
函数能提高应用的模块性和代码的重复利用率。你已经知道Python提供了许多内建函数比如print()。但你也可以自己创建函数这被叫做用户自定义函数。 16-1 定义一个函数
你可以定义一个由自己想要功能的函数以下是简单的规则
函数代码块以 def 关键词开头后接函数标识符名称和圆括号 ()。任何传入参数和自变量必须放在圆括号中间圆括号之间可以用于定义参数。函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。函数内容以冒号起始并且缩进。return [表达式] 结束函数选择性地返回一个值给调用方。不带表达式的return相当于返回 None。 语法
Python 定义函数使用 def 关键字一般格式如下
def 函数名参数列表:函数体默认情况下参数值和参数名称是按函数声明中定义的顺序匹配起来的。
让我们使用函数来输出Hello World
def hello() :print(Hello World!) hello()
Hello World!更复杂点的应用函数中带上参数变量:
#!/usr/bin/python3# 计算面积函数
def area(width, height):return width * heightdef print_welcome(name):print(Welcome, name)print_welcome(Runoob)
w 4
h 5
print(width , w, height , h, area , area(w, h))以上实例输出结果
Welcome Runoob
width 4 height 5 area 2016-2 函数调用
定义一个函数给了函数一个名称指定了函数里包含的参数和代码块结构。
这个函数的基本结构完成以后你可以通过另一个函数调用执行也可以直接从 Python 命令提示符执行。
如下实例调用了 printme() 函数
#!/usr/bin/python3# 定义函数
def printme( str ):# 打印任何传入的字符串print (str)return# 调用函数
printme(我要调用用户自定义函数!)
printme(再次调用同一函数)以上实例输出结果
我要调用用户自定义函数!
再次调用同一函数16-3 参数传递
在 python 中类型属于对象变量是没有类型的
a[1,2,3]aRunoob以上代码中[1,2,3] 是 List 类型“Runoob” 是 String 类型而变量 a 是没有类型她仅仅是一个对象的引用一个指针可以是指向 List 类型对象也可以是指向 String 类型对象。
16-4 可更改(mutable)与不可更改(immutable)对象
在 python 中strings, tuples, 和 numbers 是不可更改的对象而 list,dict 等则是可以修改的对象。
**不可变类型**变量赋值 a5 后再赋值 a10这里实际是新生成一个 int 值对象 10再让 a 指向它而 5 被丢弃不是改变a的值相当于新生成了a。**可变类型**变量赋值 la[1,2,3,4] 后再赋值 la[2]5 则是将 list la 的第三个元素值更改本身la没有动只是其内部的一部分值被修改了。
python 函数的参数传递
**不可变类型**类似 c 的值传递如 整数、字符串、元组。如funa传递的只是a的值没有影响a对象本身。比如在 funa内部修改 a 的值只是修改另一个复制的对象不会影响 a 本身。**可变类型**类似 c 的引用传递如 列表字典。如 funla则是将 la 真正的传过去修改后fun外部的la也会受影响
python 中一切都是对象严格意义我们不能说值传递还是引用传递我们应该说传不可变对象和传可变对象。
16-5 python 传不可变对象实例
#!/usr/bin/python3def ChangeInt( a ):a 10b 2
ChangeInt(b)
print( b ) # 结果是 2实例中有 int 对象 2指向它的变量是 b在传递给 ChangeInt 函数时按传值的方式复制了变量 ba 和 b 都指向了同一个 Int 对象在 a10 时则新生成一个 int 值对象 10并让 a 指向它。
16-6 传可变对象实例
可变对象在函数里修改了参数那么在调用这个函数的函数里原始的参数也被改变了。例如
#!/usr/bin/python3# 可写函数说明
def changeme( mylist ):修改传入的列表mylist.append([1,2,3,4])print (函数内取值: , mylist)return# 调用changeme函数
mylist [10,20,30]
changeme( mylist )
print (函数外取值: , mylist)传入函数的和在末尾添加新内容的对象用的是同一个引用。故输出结果如下
函数内取值: [10, 20, 30, [1, 2, 3, 4]]
函数外取值: [10, 20, 30, [1, 2, 3, 4]]16-7 函数参数详解
16-7-1 位置参数--------关键字参数---------混合使用
1位置实参:在函数调用阶段 按照从左到有的顺序依次传入的值
# 特点按照顺序与形参一一对应2 关键字参数
# 关键字实参在函数调用阶段按照keyvalue的形式传入的值
# 特点指名道姓给某个形参传值可以完全不参照顺序
def func(x,y):print(x,y)func(y2,x1) # 关键字参数
func(1,2) # 位置参数3混合使用强调# 1、位置实参必须放在关键字实参前def func(x,y):print(x,y)func(1,y2)func(y2,1)# 2、不能能为同一个形参重复传值def func(x,y):print(x,y)func(1,y2,x3)func(1,2,x3,y4)16-7-2 默认参数------位置参数与默认参数混用
4默认参数# 默认形参在定义函数阶段就已经被赋值的形参称之为默认参数# 特点在定义阶段就已经被赋值意味着在调用阶段可以不用为其赋值def func(x,y3):print(x,y)func(x1)func(x1,y44444)def register(name,age,gender男):print(name,age,gender)register(三炮,18)register(二炮,19) register(大炮,19)register(没炮,19,女)5位置形参与默认形参混用强调# 1、位置形参必须在默认形参的左边def func(y2,x): # 错误写法pass# 2、默认参数的值是在函数定义阶段被赋值的准确地说被赋予的是值的内存地址# 示范1m2def func(x,ym): # y2的内存地址print(x,ym3333333333333333333func(1)# 3、虽然默认值可以被指定为任意数据类型但是不推荐使用可变类型# 函数最理想的状态函数的调用只跟函数本身有关系不外界代码的影响m [111111, ]def func(x, ym):print(x, y)m.append(3333333)m.append(444444)m.append(5555)func(1)func(2)func(3)def func(x,y,z,lNone):if l is None:l[]l.append(x)l.append(y)l.append(z)print(l)func(1,2,3)func(4,5,6)new_l[111,222]func(1,2,3,new_l)16-7-3 可变长度的参数
6可变长度的参数*与**的用法# 可变长度指的是在调用函数时传入的值实参的个数不固定# 而实参是用来为形参赋值的所以对应着针对溢出的实参必须有对应的形参来接收6.1 可变长度的位置参数# I*形参名用来接收溢出的位置实参溢出的位置实参会被*保存成元组的格式然后赋值紧跟其后的形参名# *后跟的可以是任意名字但是约定俗成应该是argsdef func(x,y,*z): # z 3,4,5,6print(x,y,z)func(1,2,3,4,5,6)def my_sum(*args):res0for item in args:resitemreturn resresmy_sum(1,2,3,4,)print(res)# II: *可以用在实参中实参中带*先*后的值打散成位置实参def func(x,y,z):print(x,y,z)func(*[11,22,33]) # func(112233)func(*[11,22]) # func(1122)l[11,22,33]func(*l)# III: 形参与实参中都带*def func(x,y,*args): # args(3,4,5,6)print(x,y,args)func(1,2,[3,4,5,6])func(1,2,*[3,4,5,6]) # func(1,2,3,4,5,6)func(*hello) # func(h,e,l,l,o)6.2 可变长度的关键字参数# I**形参名用来接收溢出的关键字实参**会将溢出的关键字实参保存成字典格式然后赋值给紧跟其后的形参名# **后跟的可以是任意名字但是约定俗成应该是kwargsdef func(x,y,**kwargs):print(x,y,kwargs)func(1,y2,a1,b2,c3)# II: **可以用在实参中(**后跟的只能是字典)实参中带**先**后的值打散成关键字实参def func(x,y,z):print(x,y,z)func(*{x:1,y:2,z:3}) # func(x,y,z)func(**{x:1,y:2,z:3}) # func(x1,y2,z3)# 错误func(**{x:1,y:2,}) # func(x1,y2)func(**{x:1,a:2,z:3}) # func(x1,a2,z3)# III: 形参与实参中都带**def func(x,y,**kwargs):print(x,y,kwargs)func(y222,x111,a333,b444)func(**{y:222,x:111,a:333,b:4444})# 混用*与***args必须在**kwargs之前def func(x,*args,**kwargs):print(args)print(kwargs)func(1,2,3,4,5,6,7,8,x1,y2,z3)def index(x,y,z):print(index ,x,y,z)def wrapper(*args,**kwargs): #args(1,) kwargs{z:3,y:2}index(*args,**kwargs)# index(*(1,),**{z:3,y:2})# index(1,z3,y2)wrapper(1,z3,y2) # 为wrapper传递的参数是给index用的16-7-4 函数的类型提示
## : 后面是提示信息可以随意写
def regidter(name:不能写艾尼,age:至少18岁)print(name)print(age)def register(name:str,age:int,hobbies:tuple)-int: # 返回值类型为 intprint(name)print(age)print(hobbies)# 添加提示功能的同时再添加默认值
def register(name:str aini,age:int 18 ,hobbies:tuple)-int: # 返回值类型为 intprint(name)print(age)print(hobbies)17Python3 数据结构
17-1 列表
Python中列表是可变的这是它区别于字符串和元组的最重要的特点一句话概括即列表可以修改而字符串和元组不能。
以下是 Python 中列表的方法 下面示例演示了列表的大部分方法 a [66.25, 333, 333, 1, 1234.5]print(a.count(333), a.count(66.25), a.count(x))
2 1 0a.insert(2, -1)a.append(333)a
[66.25, 333, -1, 333, 1, 1234.5, 333]a.index(333)
1a.remove(333)a
[66.25, -1, 333, 1, 1234.5, 333]a.reverse()a
[333, 1234.5, 1, 333, -1, 66.25]a.sort()a
[-1, 1, 66.25, 333, 333, 1234.5]注意类似 insert, remove 或 sort 等修改列表的方法没有返回值。 17-2 将列表当做堆栈使用
列表方法使得列表可以很方便的作为一个堆栈来使用堆栈作为特定的数据结构最先进入的元素最后一个被释放后进先出。用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。例如 stack [3, 4, 5]stack.append(6)stack.append(7)stack
[3, 4, 5, 6, 7]stack.pop()
7stack
[3, 4, 5, 6]stack.pop()
6stack.pop()
5stack
[3, 4]17-3 将列表当作队列使用
也可以把列表当做队列用只是在队列里第一加入的元素第一个取出来但是拿列表用作这样的目的效率不高。在列表的最后添加或者弹出元素速度快然而在列表里插入或者从头部弹出速度却不快因为所有其他的元素都得一个一个地移动。 from collections import dequequeue deque([Eric, John, Michael])queue.append(Terry) # Terry arrivesqueue.append(Graham) # Graham arrivesqueue.popleft() # The first to arrive now leaves
Ericqueue.popleft() # The second to arrive now leaves
Johnqueue # Remaining queue in order of arrival
deque([Michael, Terry, Graham])17-4 列表推导式
列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素用其获得的结果作为生成新列表的元素或者根据确定的判定条件创建子序列。每个列表推导式都在 for 之后跟一个表达式然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组就必须使用括号。这里我们将列表中每个数值乘三获得一个新的列表 vec [2, 4, 6][3*x for x in vec]
[6, 12, 18]现在我们玩一点小花样 [[x, x**2] for x in vec]
[[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]
[12, 18][3*x for x in vec if x 2]
[]以下是一些关于循环和其它技巧的演示 vec1 [2, 4, 6]vec2 [4, 3, -9][x*y for x in vec1 for y in vec2]
[8, 6, -18, 16, 12, -36, 24, 18, -54][xy for x in vec1 for y in vec2]
[6, 5, -7, 8, 7, -5, 10, 9, -3][vec1[i]*vec2[i] for i in range(len(vec1))]
[8, 12, -54]列表推导式可以使用复杂表达式或嵌套函数 [str(round(355/113, i)) for i in range(1, 6)]
[3.1, 3.14, 3.142, 3.1416, 3.14159]17-5 嵌套列表解析
Python的列表还可以嵌套。
以下实例展示了3X4的矩阵列表 matrix [
... [1, 2, 3, 4],
... [5, 6, 7, 8],
... [9, 10, 11, 12],
... ]以下实例将3X4的矩阵列表转换为4X3列表 [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]以下实例也可以使用以下方法来实现 transposed []for i in range(4):
... transposed.append([row[i] for row in matrix])
...transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 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
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]17-6 del 语句
使用 del 语句可以从一个列表中依索引而不是值来删除一个元素。这与使用 pop() 返回一个值不同。可以用 del 语句从列表中删除一个切割或清空整个列表我们以前介绍的方法是给该切割赋一个空列表。例如 a [-1, 1, 66.25, 333, 333, 1234.5]del a[0]a
[1, 66.25, 333, 333, 1234.5]del a[2:4]a
[1, 66.25, 1234.5]del a[:]a
[]也可以用 del 删除实体变量 del a17-7 元组和序列
元组由若干逗号分隔的值组成例如 t 12345, 54321, hello!t[0]
12345t
(12345, 54321, hello!)# Tuples may be nested:
... u t, (1, 2, 3, 4, 5)u
((12345, 54321, hello!), (1, 2, 3, 4, 5))如你所见元组在输出时总是有括号的以便于正确表达嵌套结构。在输入时可能有或没有括号 不过括号通常是必须的如果元组是更大的表达式的一部分
17-8 集合
集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。可以用大括号({})创建集合。注意如果要创建一个空集合你必须用 set() 而不是 {} 后者创建一个空的字典下一节我们会介绍这个数据结构。
以下是一个简单的演示 basket {apple, orange, apple, pear, orange, banana}print(basket) # 删除重复的
{orange, banana, pear, apple}orange in basket # 检测成员
Truecrabgrass in basket
False # 以下演示了两个集合的操作
...a set(abracadabra)b set(alacazam)a # a 中唯一的字母
{a, r, b, c, d}a - b # 在 a 中的字母但不在 b 中
{r, d, b}a | b # 在 a 或 b 中的字母
{a, c, r, d, b, m, z, l}a b # 在 a 和 b 中都有的字母
{a, c}a ^ b # 在 a 或 b 中的字母但不同时在 a 和 b 中
{r, d, b, m, z, l}集合也支持推导式 a {x for x in abracadabra if x not in abc}a
{r, d}17-9 字典
另一个非常有用的 Python 内建数据类型是字典。序列是以连续的整数为索引与此不同的是字典以关键字为索引关键字可以是任意不可变类型通常用字符串或数值。理解字典的最佳方式是把它看做无序的键值对集合。在同一个字典之内关键字必须是互不相同。一对大括号创建一个空的字典{}。
这是一个字典运用的简单例子 tel {jack: 4098, sape: 4139}tel[guido] 4127tel
{sape: 4139, guido: 4127, jack: 4098}tel[jack]
4098del tel[sape]tel[irv] 4127tel
{guido: 4127, irv: 4127, jack: 4098}list(tel.keys())
[irv, guido, jack]sorted(tel.keys())
[guido, irv, jack]guido in tel
Truejack not in tel
False构造函数 dict() 直接从键值对元组列表中构建字典。如果有固定的模式列表推导式指定特定的键值对 dict([(sape, 4139), (guido, 4127), (jack, 4098)])
{sape: 4139, jack: 4098, guido: 4127}此外字典推导可以用来创建任意键和值的表达式词典 {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}如果关键字只是简单的字符串使用关键字参数指定键值对有时候更方便 dict(sape4139, guido4127, jack4098)
{sape: 4139, jack: 4098, guido: 4127}17-10 遍历技巧
在字典中遍历时关键字和对应的值可以使用 items() 方法同时解读出来 knights {gallahad: the pure, robin: the brave}for k, v in knights.items():
... print(k, v)
...
gallahad the pure
robin the brave在序列中遍历时索引位置和对应值可以使用 enumerate() 函数同时得到 for i, v in enumerate([tic, tac, toe]):
... print(i, v)
...
0 tic
1 tac
2 toe同时遍历两个或更多的序列可以使用 zip() 组合 questions [name, quest, favorite color]answers [lancelot, the holy grail, blue]for q, a in zip(questions, answers):
... print(What is your {0}? It is {1}..format(q, a))
...
What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.要反向遍历一个序列首先指定这个序列然后调用 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
pear18Python3 模块
18-1 模块
## 内置模块
## 第三方模块
## 自定义模块## 模块的四种形式
1 使用Python编写的py文件
2 已被编译为共享库或DLL的C或C扩展
3 把一系列模块组织到一起的文件夹文件夹下面有个__init__.py 该文件夹称为包
3 使用C编写并链接到Python解释器的内置模块import foo
## 首次导入模块会发生什么
1执行foo.py
2, 产生foo.py的命名空间
3在当前文件中产生的有一个名字foo,改名字指向2中产生的命名空间## 无论是调用还是修改与源模块为准与调用位置无关## 导入模块规范
1 Python内置模块
2Python第三方模块
3自定义模块## 起别名import foo as f## 自定义模块命名应该纯小写下划线## 可以在函数内导入模块18-2 写模块时测试
# 每个Python文件内置了__name__,指向Python文件名# 当foo.py 被运行时
__name__ __main__# 当foo.py 被当做模块导入时
__name__ ! __main__##### 测试时可以if判断,在foo.py文件中写以下判断
if __name__ __main__ :## 你的测试代码18-3 from xxx import xxx
# from foo import x 发生什么事情
1 产生一个模块的命名空间
2 运行foo.py 产生将运行过程中产生的名字都丢到命名空间去
3 在当前命名空间拿到一个名字改名字指向模块命名空间18-4 从一个模块导入所有
#不太推荐使用
form foo import *
# 被导入模块有个 __all__ []
__all__ [] # 存放导入模块里的所有变量和函数 默认放所有的变量和函数也可以手动修改foo.py__all__ [x,change]x 10def change():global xx 20a 20b 30run.py from foo import * ## * 导入的是foo.py里的 __all__ 列表里的变量和函数print(x)change()print(a) # 会报错因为foo.py 里的 __all__ 列表里没有a变量18-5 sys.path 模块搜索路径优先级
1 内存内置模块
2 从硬盘查找import sys
# 值为一个列表存放了一系列的文件夹
# 其中第一个文件夹是当前执行所在的文件夹
# 第二个文件夹当不存在因为这不是解释器存放的是pycharm添加的
print(sys.path)
# sys.path 里放的就是模块的存放路径查找顺序
[
E:\\Desktop\\python全栈\\模块, E:\\Desktop\\python全栈, D:\\软件\\pycharm\\PyCharm 2021.3.1\\plugins\\python\\helpers\\pycharm_display, D:\\软件\\python\\python310.zip, D:\\软件\\python\\DLLs, D:\\软件\\python\\lib, D:\\软件\\python, C:\\Users\\艾尼-aini\\AppData\\Roaming\\Python\\Python310\\site-packages, D:\\软件\\python\\lib\\site-packages, D:\\软件\\python\\lib\\site-packages\\win32, D:\\软件\\python\\lib\\site-packages\\win32\\lib, D:\\软件\\python\\lib\\site-packages\\Pythonwin, D:\\软件\\pycharm\\PyCharm 2021.3.1\\plugins\\python\\helpers\\pycharm_matplotlib_backend
]18-6 sys.modules 查看内存中的模块
import sys
print(sys.module) # 是一个字典存放导入的模块## 可以判断一个模块是否已经在内存中
print(foo in sys.module)
18-7 编写规范的模块
this module is used to ...... # 第一行文档注释
import sys # 导入需要用到的包
x 1 # 定义全局变量
class foo: # 定义类pass
def test(): #定义函数passif __name__ __main__:pass
