概述
目录
????一、前言
????二、while循环（中等）
????1、循环是什么（简单）
????2、while循环（中等）
????①、基本循环（简单）
????②、死循环（简单）
????③、continue，break和pass语句（中等）
????④、while else（中等）
????⑤、斐波那契数列（中等）
????三、迭代（中等）
????1、数组的接力棒——迭代器（中等）
????①、一场接力赛（简单）
????②、真正的变量（中等）
????③、关于next（简单）
????2、迭代循环for（中等）
????①、基本使用（简单）
????②、for else语句（中等）
????③、range函数（中等）
????④、for循环实战代码（干货）
????四、函数（困难）
????1、函数是什么（中等）
????2、基本创建方法（中等）
????3、关于参数（困难）
????①、形参与实参（中等）
????②、默认参数（中等）
????③、关键字参数（困难）
????④、不定长参数（困难）
????4、全局变量与局部变量（困难）
????①、基础使用（中等）
????②、真假变量（困难）
????③、改变局部变量（干货）
????5、函数嵌套（简单）
????6、关于return（中等）
????7、匿名函数（中等）
????8、函数简单程序（干货）
????8、函数的实际用途（干货）
????五、模块（中等）
????1、常见的内置模块（简单）
????①、什么是内置模块（中等）
????②、调用内置模块（干货）
????③、建议学习步骤（干货）
????六、习题
????七、结束语
本文为原创作品，若要引用请于作者联系，抄袭必究！
????一、前言
上一篇文章的效果不错，又赶忙再写了一篇。
别问我目录为什么没有第三方模块，问就是后来在手机上改的，改不了目录了，有时间加上。
下载了一个剪映，终于有一个好看的封面了qwq。
按照教程一步步走，接下来就要攻克这四大难题：循环，迭代，函数，模块，就放在一起出吧。
本文会对循环，迭代，函数，模块的任何类型、写法、功能进行详细讲解。写文不易，智齿一下！
????二、while循环（中等）
????1、循环是什么（简单）
假设你现在写了一段记录数据的代码，现在你的全班50个人都要来统计数据。你是不是会运行50次？费力还费时间。
我们来介绍一个新东西——循环。
我们可以用循环，让程序一直重复。
这里指的循环就是让一段代码一直重复。
python的循环很少，只有while和for，并且for还要归到迭代一栏去，这样算就只有while了。
我们先来学习while：
????2、while循环（中等）
????①、基本循环（简单）
我们先来学习while循环，最简单的循环。
先来看一个例子：
while 1==1:
print("只因你太美")输出：只因你太美
只因你太美
只因你太美
…
来解析一下代码。
这个代码的意思就是：如果1==1，那么就执行里面的代码，执行完毕之后跳到开头，再次判断条件，再次运行下面的代码，直到条件不成立，退出循环，执行下面的代码。
格式：
while 条件:
执行语句
如果这个条件成立，则执行下面的代码；如果不成立，则退出循环。
写的时候要注意冒号和缩进。
举个例子：
a=0
while a<=5:
print(a)
a=a+1
print（"over"）输出：0
1
2
3
4
5
over
来梳理一下吧。
a的初始值为0，之后每进入一次循环，就输出a，并且a自增，直到a>5时退出循环并且输出over。
现在，大家应该都懂了while循环吧。
另外：写循环你最好要有注释的好习惯，以后写循环套判断判断套循环的玩意儿，你自己试着理解一下下面的代码:
a,b,c=0,0,0
while a<=5:
if True:
while b<=5:
if a==4:
while c<=5:
print(a)
c+=1
c=0
b+=1
b=0
a=a+1
print(a)理解吧。
咱就是说，这程序不写也罢。
????②、死循环（简单）
死循环，顾名思义就是一直重复执行的循环。
上文的第一个实例其实就是一个死循环。
要想让这个循环一直重复执行，条件表达式就要永远为True。条件表达式为1，2，1==1之类的，全部都是死循环。
死循环多用于游戏里，等你以后接触pygame便会学习游戏循环，还有服务端的实时请求。其他程序也会有死循环的出现。只要是一直重复的程序，就一定会有死循环。
死循环可以用ctrl+c中断。
????③、continue，break和pass语句（中等）
我们先来讲continue。
continue的意思是：跳过循环的剩下代码，从头执行这个循环。
多说无益，先举个例子：
a=0
while a<5:
a=a+1
if a==4:
continue
print(a)输出：1
2
3
5
解析一下:
这是一个正常的循环，不过多了一个if a==4和continue，他的意思就是如果a是4的话，就跳过后面的print(a)不管了，直接回到条件判断的地方，跳过了4的输出。
这就是continue的用法。
接下来讲break。
还是先看实例：
a=0
while a<5:
a=a+1
if a==4:
break
print(a)
print("over")输出：1
2
3
over
我们把上面代码的continue换成了break，当break执行之后，循环就结束了。
由此可见：break的用法是：跳出循环，直接去执行循环后面的代码。
接下来是pass
顾名思义，pass的意思就是跳过。
pass其实就是用来占位置的，例如：
if 1==1:
pass
else:
print("1")输出：
这个程序如果我们不加pass，就会报错，pass没有任何效果，只是用来占位置使程序不报错。
????④、while else（中等）
else语句不仅可以连接if，还可以连接while和for，先说while。老规矩，先来看例子：
a=0
while a<5:
a+=1
print(a)
else:
print("只因你太美")输出：1
2
3
4
5
只因你太美
大家可能会说：应该是当while后面的条件为False时，就会执行else后面的语句。
或者会说：应该是正常结束循环执行else后面的语句，break退出不执行。
那么这两种理解方法哪个才是正确的呢？
请看看下面的例子：
a=0
while a<5:
a+=1
if a==4:
a+=2
break
else:
print("只因")输出：
这时是a是6，大于5，却还是没有执行else后面的语句，所以可以判断，是和break退出有关的。
可能这个小实验有点难理解，但是你只要记住，正确的是：
正常结束循环执行else后面的语句，break退出不执行。
while else是比较奇葩的，循环正常退出之后执行，不正常退出反而不执行，python大部分语言都是说人话的，这个有些特殊，就只有单独记了。
这种方法可以侦测你是因为什么退出的循环，不用再用变量去记录。
????⑤、斐波那契数列（中等）
接下来看看一个简易的while循环实现的代码——输出斐波那契数列。难度：????????????
a=0
b=1
while a<=100:
print(b,end=",")
a,b=b,a+b
print("over")输出：1,1,2,3,5,8,13,21,34,55,89,144,over
这是100以内的斐波那契数列，可能会难理解，我们随着程序的执行步骤试着理解一下：
#首先，a为1，b为0。
#第一次循环：输出b：1，a=b也就是1，b=a+b也就是0+1也就是1。
#第二次循环：输出b：1，a=b也就是1，b=a+b也就是1+1也就是2。
#第三次循环：输出b：2，a=b也就是2，b=a+b也就是1+2也就是3。
#第四次循环：输出b：3，a=b也就是3，b=a+b也就是2+3也就是5。
#第五次循环：输出b：5，a=b也就是5，b=a+b也就是3+5也就是8。
#第六次循环：输出b：8，a=b也就是8，b=a+b也就是5+8也就是13。
#第七次循环：输出b：13，a=b也就是13，b=a+b也就是8+13也就是21。
#第八次循环：输出b：21，a=b也就是21，b=a+b也就是13+21也就是34。
#第九次循环：输出b：34，a=b也就是34，b=a+b也就是21+34也就是55。
#第十次循环：输出b：55，a=b也就是55，b=a+b也就是34+55也就是89。
#第十一次循环：输出b：89，a=b也就是89，b=a+b也就是55+89也就是144。
#第十二次循环：b大于100，结束循环，输出over。斐波那契数列的后一个数=前两个数的和，我们用前两个数相加输出的方法巧妙破解了这道题。
如果你看懂了，恭喜你，已经了解了循环。
????三、迭代（中等）
????1、数组的接力棒——迭代器（中等）
????①、一场接力赛（简单）
迭代器，我们可以用接力棒去理解。这把接力棒就是一个变量。
迭代器可以迭代的有：列表，元素，字符串，字典，这叫做可迭代对象。还有一些其他的可迭代对象，我们这里先不学。
当程序运行后，这把接力棒就会一棒棒传下去，直到传到最后一位。
迭代器的英文是list_iterator，前面的list为要迭代的目标的英文。
我们先来了解一下迭代器的创建。
我们创建一个迭代器要用iter，这时候就相当于举办了一场接力赛，迭代的数组或字符串就相当于每一位选手。
b=[1,2,3]
a=iter(b)开启这种接力赛或者传递接力棒，用next，这时候b就是迭代对象。
格式：
变量=iter(可迭代对象)
print(next(a))输出：1
这时候，就相当于开始了比赛，就是迭代器启动。
print(next(a))输出：2
这时候，就相当于把接力棒传到了第二位选手，就是迭代下一位。
print(next(a))输出：3
这时候，我们把列表里的最后一位看成最后一棒，此时如果再往下传递就没有人来接了，就是迭代目标没有了。
如果我们接着传送这一棒呢？
print(next(a))输出：Traceback (most recent call last):
File "<string>", line 6, in <module>
StopIteration
你是想把接力棒带回家？
记住，next只能开始比赛和传递接力棒，不能结束接力，如果自己也确定不了迭代对象的长度，就用len函数或者异常捕捉吧，以后会学。
????②、真正的变量（中等）
其实，迭代器是一个虚假的变量。
a=[1,2,3]
b=iter(a)
print(next(b))
print(b)输出：1
<list_iterator object at 0x7f63099c6d90>
为什么b现在明明是1却显示这一串地址？
其实，在迭代器里面，这个变量b是没有返回值的，只有next(b)才有返回值，按理来说，next(b)他才是一个真正的变量。至于b…啥也不是。
我们试着把next(b)看成变量来理解，一些问题就变简单了。
????③、关于next（简单）
next()可以单独生效，只不过没有了返回值。
a=[1,2,3,4]
b=iter(a)
next(b)
print(next(b))输出：2
还有一些比较高级的例如把一个类作为一个迭代器，这里就不讲了。
????2、循环for（中等）
????①、基本使用（简单）
for比较特殊，是一个循环，又长得像迭代器，本身还是用来遍历的。…反正差不多，放在这一栏吧。话不多说，先来看例子：
a=[1,2,3,4]
for b in a:
print(b)输出：1
2
3
4
解析一波。
for b in a的意思就是，将迭代器b一直往后迭代直到结束，每迭代一次就执行一次循环里的代码。
这时候，b就不受上文没有返回值的限制了，结束了还不会报错，还不用单独用一行创建变量，优点很多。不过如果每次迭代之后要执行的代码都不同，那还是算了吧。
????②、for else语句（中等）
有了前面while else的启示，for else是不是也是这样呢？做个实验吧：
a=[1,2,3,4]
for b in a:
if b==3:
break
else:
print("是因为break退出而else语句生效的")
for b in a:
pass
else:
print("是因为正常循环退出而else语句生效的")输出：是因为正常循环退出而else语句生效的
和while else语句是一样的。
????③、range函数（中等）
很多情况，要迭代的目标是按顺序排列的数字，这时候，就可以用range来简化。
如果填一个值，则是要遍历0到这个值。
for a in range(5):
print(a,end=",")输出：0,1,2,3,4,
记住，最后一位不算数，例如你输出range(5)，输出的是0,1,2,3,4。
如果填两个值，则是要遍历第一个值到第二个值。
for a in range(5,10):
print(a,end=",")输出：5,6,7,8,9
如果填三个值，第三个值就是间距。
for a in range(1,10,2):
print(a,end=",")输出：1,3,5,7,9,
其实，数据类型不单单有六个，这其实只是常见的，还有一些数据类型。range就是一个。不信？我们来用type测试一下。
print(type(range(10)))输出：<class 'range'>
其实也是有range类型的。
那么我们能不能把range类型存到变量呢？
a=range(10)
print(a)输出：range(0, 10)
range只能作为一个迭代器使用。
????④、for循环实战代码（干货）
来做一些实战代码吧。
1，五行代码实现九九乘法表： 难度：????????????
for a in range(1,10):
for b in range(1,10):
if a>=b:
print(b,"x",a,"=",a*b,end=" ")
print("n")输出：太长了，放图片吧。
思路：
第一行，创建迭代器a，作为第二个数
第二行，创建迭代器b，作为第一个数
第三行，侦测a是否大于等于b，以免出现2x1,3x1之类的情况
第四行，如果是则输出一个标准的算式，结尾为t
第五行，写完一行之后换行接着写
2，质数检测器 难度：????????????????
a=int(input("要检测1到多少位的质数？"))
zhishu=[]
heshu=[]
for b in range(2,a):
for c in range(2,b):
if b%c==0:
print(c,"x",b//c,"=",b)
heshu.append(b)
break
else:
print(b,"是质数")
zhishu.append(b)
print("质数表：",zhishu)
print("合数表：",heshu)输出：还是看图：
思路：
第一行：询问要检测1到多少位的质数并且用变量a保存
第二第三行：创建列表zhishu保存质数，heshu保存合数
第四行：用于侦测1到a位数的for循环
第五行：用于侦测这个数可以整除2到b-1的哪一个数的循环
第六行：如果b可以被c整除，意思就是b是质数
第七行：按照算式格式输出
第八行：列表heshu添加这个数
第九行：退出循环
第十行：for else语句，正常结束循环则是b是质数的时候执行
第十一行：输出b是质数
第十二行：列表质数添加这个数
第十三十四行：侦测结束，输出质数表和合数表
如果这两个例子你都理解了，恭喜你，你已经掌握了for循环和迭代器。
????四、函数（困难）
????1、函数是什么（中等）
函数，便是程序已经提前写好的代码，让你直接拿过来用，例如print，在python3已经变成了函数。还有上文数据类型与变量讲的abs函数、round函数，字典字符串列表集合函数，都属于函数。
本文我们不讲这些函数。
想一想，如果你要重复利用一段代码，你是不是要把代码Ctrl+c，Ctrl+v到你所需要的地方？
我们可以自己来创建一个函数，用来保存一些代码块，在需要的时候随时调用。这叫做封装。这种函数有自己的名称：用户自定义函数。
????2、基本创建方法（中等）
我们先了解一下创建格式。
def 函数名(参数列表):
函数体
这里面，函数名是你给这些代码取的名字。
当你使用函数的时候会填写一些变量，参数列表就是要填写的变量，可以有任意数量个，0个也行。
函数体则是被封装的代码。
先来看一个简单的例子：
def big(a,b):
if a>b:
return a
else:
return b
print(big(1,2))输出：2
这是一个最基本的比较两数大小的函数，开始讲解。
首先创建一个名称叫做big的函数，需要填入两个参数：a和b。
当使用函数后，程序比较a和b的大小。
在这里，return的意思是返回值。函数是有的有返回值，有的没有返回值。如果填写return就是有返回值。
再来根据程序的思维执行一下代码。
首先，运行print(big(a,b))，侦测到启动了函数，运行big函数里面的代码。参数代入进去，现在a是1，b是2。a并不大于b，返回False，执行else后面的代码，返回b，程序结束。因为b现在是2，返回的就是2。
????3、关于参数（困难）
????①、形参与实参（中等）
我们先来了解两个名词。
def a(b,c):
print(b,c)
d="只因"
e="你太美"
a(d,e)输出：只因 你太美
这时候，我们在调用函数的时候填入的参数d和e就是实参，接收的参数b和c就是形参。懂？
????②、默认参数（中等）
默认参数，用于实参数量<形参数量。
函数里面的参数可以不填，也可以填多个。如果函数所需要的参数与所填入的参数不相等怎么办？
def a(c,b):
print("只因你太美")
a(1)输出：Traceback (most recent call last):
File "<string>", line 3, in <module>
TypeError: a() missing 1 required positional argument: 'b'
不好意思，报错。形参数量必须等于实参数量。
不过，我们可以给形参一个默认值。
默认值，举个例子。例如上文讲过了log函数，如果不填底数就默认底数为e。
我们可以这样，在参数后面加个=，代表默认值，如果不填就默认是这个默认值：
def a(c,b=114514):
print("只因你太美")
a(1)
输出：只因你太美
会了吧？
这里注意一下：有默认值的参数必须放在没有默认值的参数后面。
????③、关键字参数（困难）
还有一种关键字参数，当填入的参数与接受的参数顺序不一致时，就用=。
他与默认参数的不同点是，默认参数在形参上加=号，关键字参数在实参上加=号。
def a(b,c):
print(b,c)
a(c=1,b=2)输出：2 1
很简单理解吧？
这里科普一下：end=""，大家应该在print里面见过他，这其实就是一个关键字参数。我们用help看一下print的说明：
print(...)
print(value, ..., sep=' ', end='n', file=sys.stdout, flush=False)
可以看到，print有很多可选参数，如果我们直接写print(a,“，”)，程序会理解成输出a和逗号，所以要用关键字参数的形式。
同样注意一下：关键字参数必须放在非关键字参数后面。
????④、不定长参数（困难）
紧接着第二部分，如果填入的实参数量>形参数量呢？
肯定还是会报错。
这时候，就要用一个符号：*了，用在形参最后一个参数的前面。
*既可以代表乘号，又可以让多个参数结合。
*的作用：如果填写的参数数量>程序需要的参数数量，那么就将最后一个参数和多出的参数结合成元组。这叫做不定长参数。举个例子：
def a(b,*c):
print(type(c))
print(c)
a(1,2,3,4,5,6)输出：<class 'tuple'>
(2, 3, 4, 5, 6)
我们可不可以给星号换个地方？
上面的代码把星号加在b前面，输出如下：
Traceback (most recent call last):
File "<string>", line 7, in <module>
TypeError: a() missing 1 required keyword-only argument: 'c'
不好意思不行。
如果我们想把他保存成字典，就用两个星号，参数要用关键字参数的形式，不过这里的意思可不是关键字，而是等号左边的为键，右边为值。
def a(b,**c):
print(type(c))
print(c)
a(1,d=2,e=3)输出：<class'dict'>
{'d':2,'e':3}
????4、全局变量与局部变量（困难）
????①、基础使用（中等）
我们先来看一个例子：
def a():
b=0
a()
print(b)输出：Traceback (most recent call last):
File "<string>", line 4, in <module>
NameError: name 'b' is not defined
报错的大概意思就是不知道b是啥，大多数情况是因为没有声明变量而报错的。
但是已经声明变量了啊，b=0，并且函数也调用了啊，怎么还报错呢？
算了，不卖关子了，这是因为b是局部变量。
全局变量，就是在任何时候都可以调用的变量。
局部变量，就是只能在一个函数里面使用的变量。
程序运行时，为了节省内存，只要你是在函数中声明的变量，他就是局部变量，就不能在外部使用。
def a(b):
pass
a(3)
print(b)输出：Traceback (most recent call last):
File "<string>", line 4, in <module>
NameError: name 'b' is not defined
从这个例子可以看出，形参也是局部变量。
????②、真假变量（困难）
全局变量和局部变量的名字可以一样，例如：
a = 1
def b():
a=2
print(a)
def c():
print(a)
b()
c()输出：2
1
当调用函数b()的时候，应该理解成新声明了一个局部变量a，这时候优先输出局部变量a。
当调用函数c()的时候，因为在函数c()里面没有局部变量a，所以输出全局变量a。
程序运行时，先检测有没有一个名字为a的局部变量，再检测有没有一个名字为a的全局变量。
????③、改变局部变量（干货）
如果我们想把局部变量变成全局变量，可以有两种方法。
1：用global，在声明变量之前把他变成全局变量。
a = 1
def b():
global a
a=2
print(a)
def c():
print(a)
b()
c()输出：2
2
这时候，就相当于告诉程序，我要声明的是全局变量。
2:直接在函数外声明变量，函数内不声明直接用
a=1
a=2
def b():
print(a)
def c():
print(a)
b()
c()输出：2
2
后续学类的时候你还会进一步了解局部变量与全局变量。
????5、函数嵌套（简单）
函数可以嵌套使用，可以无限套娃。
def a():
def b():
print("只因你太美")
b()
a()
输出：只因你太美i
输出：2
我们在a函数里面又调用和使用了b函数，可以证明函数可以嵌套。你可能以为没用，但我们下期会学习作用域，到时候就有用了。
????6、关于return（中等）
上文已经说了，return是函数的返回值。
那么当成程序执行到return会发生什么呢？
def a():
print("只因")
return '114514'
print("你太美")
a()输出：只因
当程序执行到return时，代码就结束了，不管后面还有没有。
如果return返回多个值，就要用逗号了。
def a(a,b):
return a,b
c=a(1,2)
print(c)
输出：(1,2)
诶，怎么加了括号啊？返回的是元组吗？
我们用在上面的代码后面加一句print(type(c))，输出：
<class'Tuple'>
看来返回的确实是元组。
另外，如果没有返回值，我们强行获取会怎么样？
def a():
print("只因你太美")
b=a()
print(b)输出：只因你太美
None
你在想什么！
????7、匿名函数（中等）
还有一种函数叫做匿名函数，只有一行，用lambda定义。格式：
lambda 形参:返回值
这里只学简单的应用，其他高级的还是bye bye吧。例如：
a=lambda b,c:b+c
print(a(1,2))输出：3
这就相当于:
def a(b,c):
return b+c
print(a(1,2))这就相当于把简单的函数简化了。
不过无论函数体再长，也只能在一行上，所以为了美观，还是建议用def吧。
????8、函数简单程序（干货）
1，计算三角形面积 难度：????????
def a(b,c):
return b*c/2
print(a(3,6))输出：9.0
很简单吧，思路：
第一行，定义函数a，给参数b和c。
第二行，返回b*c除以2的值
第三行：输出底为3，高为6的三角形面积
2，计算一个数的阶乘 难度：????????????????
b,c=1,1
def jsjc(a):
global b,c
while b<=a:
c=c*b
b+=1
return c
while 1:
d=int(input())
print("阶乘：",jsjc(d))输入：3
输出：6
输入：5
输出：120
…
阶乘就是1到这个数一直乘，例如4的阶乘是1x2x3x4。
思路：
第一行：声明变量b，c为1，1
第二行：定义函数jsjc用来进行阶乘运算
第三行：将b和c设置为全局变量
第四行：重复执行，进行阶乘运算
第五行：将c设置为c*b
第六行：b自增
第七行：循环结束后c就是阶乘结果，返回c
第八行：死循环执行用户输入和输出结果
第九行：用户输入要进行运算的数
第十行：调用函数，输出结果
????8、函数的实际用途（干货）
为什么要用函数？有以下的好处：
1，可以随时使用这段代码，不用一遍一遍复制
2，美观，将一个部分的代码封装，逻辑性更强
3，扩展性高，一个函数可以用在多个脚本
自此函数的学习结束，接下来是模块的学习。
????五、模块（中等）
我们开始学习模块。
模块，英文是Module，分为内置模块、用户自定义模块和第三方模块。
模块就是别人提前写好的一些函数和代码放在一起，你只要调用他就能使用里面的函数和代码。
python之所以强大，很大原因是他强大的第三方库，有几百多个。我上网查了查，找到了一个这样的链接：python第三方库大全，网站点开有点卡，可以参考参考，足以看见python第三方库的强大。
我们先讲内置模块。
????1、常见的内置模块（简单）
????①、什么是内置模块（中等）
内置模块，就是python自己带的模块，拿出来就能用里面的函数。我们之前已经接触了math模块。
在使用这个函数的时候，一定要表明他是哪个模块的，例如用log函数就写math.log。
不过如果你用下文的from语句就不需要表明，直接用log。
这里注意一下，这个文件的名字不能与模块重名，因为python还可以导入代码，程序会报错。例如你既然导入了math模块，文件名就不能用math.py了。
我们可以用dir来查看一个模块有哪些函数。例如：
import math
print(dir(math))输出：['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']
这就是math模块的所有函数。如果不了解一个函数怎么用，可以用help，举个例子：
import math
help(math.log)输出：log(...)
log(x, [base=math.e])
Return the logarithm of x to the given base.
If the base not specified, returns the natural logarithm (base e) of x.
Help on built-in function print in module builtins:
看不懂英文？百度去，或者去python中文官网看解析。
????②、调用内置模块（干货）
调用模块的方法，有5种，拿math模块举个例子：
1，import 模块名，即可调用这个模块。例如：import math。
2，from 模块名 import 函数，在这个模块里面调用其中的几个函数来使用，例如：from math import log，就是只从math模块里面调用log函数，其他不调用，用于节省内存。
3，from 模块名 import *，就是在这个模块里面调用所有你使用的函数或，相当于import 模块名，还更节省内存。
这里提醒一下，建议导入模块放在第一位，例如下面代码，你猜猜会输出什么？
e=3
from math import *
print(e)输出：2.718281828459045
这是因为math模块有常量e，所以会输出他，只要将导入模块放在第一行就不会有这种乌龙。
4，import 模块名 as 简化模块名，由于模块的名字可能会有些长，可以给他起一个短一点的名字。例如：import math as m，后面直接在函数前面加m.就行，如m.log。
5，from 模块名 import 函数1,函数2…，在第二条的基础上导入进来多个函数，例如from math import log,log10,floor。
????③、建议学习步骤（干货）
????2、第三方模块
????①、什么是第三方模块
第三方模块，顾名思义就是别人写的模块，我们也可以拿来用，不过你先要下载。
大家可以看一下上面的链接，这就是python的强大之处——第三方模块，几百多个模块，你两年半不吃不喝不睡估计也学不完。
大部分第三方模块pip包都可以下载，我们先要下载pip包，在比较高的版本pip包是下载python的时候自带的，这里就不讲怎么下载了。
我们打开平时运行交互式python的地方——命令行，先别急着输入python，输入pip install ***，***为你要安装的模块名字，例如安装numpy就输出pip install numpy，等待一下，不出现红色或者黄色的警告就是安装成功了。
安装的时候默认的是国外的网，比较慢，可以用国内的网。
????②、建议学习步骤
当你把平常python的那些语法都吃透了之后，就要和第三方模块打交道了。这里建议学习步骤如下：
1，numpy模块，初步练手就行，不用深究
2，pygame模块，建议在将基础知识全部吃透之后再学，必须深究
之后随便开坑，还是不要开太难的。
????六、习题
#代码1
a=0
c=1
def b():
global a
a=1
b=3
c=2
答案：简答题上面都有，代码题能过就行，安装题自己安装，懒得写了，。
????七、结束语
啥？你问我为啥没用户自定义模块？
这玩意儿等到下期讲。
啥？你说这期好难？
难的还在下期，会对class类进行详解，让你知道啥叫难。
写文不易，支持一下吧！
散会！
--------------------------------------------------------end------------------------------------------------------------
最后
以上就是和谐歌曲为你收集整理的python详解（3）——循环，迭代，函数，模块????一、前言????二、while循环（中等）????三、迭代（中等）????四、函数（困难）????五、模块（中等）????六、习题????七、结束语的全部内容，希望文章能够帮你解决python详解（3）——循环，迭代，函数，模块????一、前言????二、while循环（中等）????三、迭代（中等）????四、函数（困难）????五、模块（中等）????六、习题????七、结束语所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
发表评论 取消回复