python的程序由包(package)、模块(module)和函数组成。模块是处理某一类问题的集合，模块由函数和类组成，包是由一系列模块组成的集合。包必须至少包含一个__init__.py文件，该文件内容可以为空，它用于标识文件夹是一个包。
1. 模块
模块是把一组相关的函数或代码组织到一个文件中，一个文件即是一个模块，模块由代码、函数或类组成。
1.1 模块的创建
##########myModule.py文件##########
#自定义模块
def func():
print('myModule.func()')
class MyClass:
def Func(self):
print('myModule.MyClass.Func()')
###########call_myModule.py文件#########
import myModule #导入模块
myModule.func() #调用模块的函数
myClass = myModule.MyClass() #调用模块的类
myClass.Func() #调用模块的类的方法
myModule.py和call_myModule.py必须放在同一个目录下，或放在sys.path所列车的目录下，否则python解释器找不到自定义的模块。当python导入一个模块时，python首先查找当前路径，然后查找lib目录，site-packages目录和环境变量PATHONPATH设置的目录。如果导入的模块没有找到，在以上路径搜索一下是否含有这个模块。
1.2 模块的导入
- 导入模块：调用模块的函数或类，需要以模块名作为前缀。如：模块名.func()
import 模块名
- 导入模块的函数：这样调用不需要以模块名作为前缀。如：func()
from 模块名 import 函数名
- 导入模块下所有的类和函数：
from 模块名 import *
同一个模块支持多条import语句。
##########module_count.py##########
count = 0
def func():
global count
count += 1
return count
##########call_module_count.py##########
import module_count
print(module_count.func()) #1
import module_count
print(module_count.func()) #2
python的import可以置于程序中任意位置，甚至放在条件语句中。
#修改上面代码如下
##########call_module_count.py##########
import module_count
print(module_count.func()) #1
import module_count
print(module_count.func()) #2
if module_count.count >0:
module_count.count=0
else:
import module_count
print(module_count.count) #0
1.3 模块的属性
模块有一些内置属性，如__name__、__doc__。__name__用于判断当前模块是否是程序的入口，如果当前程序正在被使用，__name__的值为"__main__"。通常给每个模块都添加一个条件语句，用于单独测试该模块的功能。
##########module.py##########
'''测试模块的__name__属性'''
if __name__ == "__main__":
print("模块作为主程序运行！！")
else:
print("模块被另一个程序调用！！！")
'''
运行此模块结果：
模块作为主程序运行！！
'''
导入以上模块运行测试：
##########module_call.py########## import module print(module.__doc__) ''' 模块被另一个程序调用！！！ 测试模块的__name__属性 '''
2. 函数
函数是一段可以重复多次调用的代码，通过输入的参数值返回需要的结果,return如果不写，会被隐式加上，返回值为None。return的返回值可以是任意对象，如果输出多个，则以元组的形式返回。
2.1 函数的定义
def 函数名(参数1，参数2...)：
函数主体...
return 返回值
函数定义与调用：
def count(x,y): #函数定义
res = x+y #函数主体
return res #返回值
ret = count(3,5) #函数调用
print(ret)
2.2 函数的参数
形式参数：函数()里的参数
实际参数：调用函数()里传入的参数
python中一切皆对象，所以参数只支持引用传递的方式。python通过名称绑定的机制，把实际参数的值和形式参数的名称绑定在一起。即把形式参数传递到函数所在的局部命名空间中，形式参数和实际参数指向内存中同一个存储空间。
- 位置参数：实际参数与形式参数一一对应。
def count(x,y):
print(x,y)
count(1,2) #1 2
count(2,1) #2 1
- 默认参数：
def count(x,y=5):
res = x+y
return res
print(count(2)) #7
print(count(2,3)) #5
特殊情况：由于参数实现了名称绑定机制，在使用默认参数时，可能会特殊情况。
def append(args=[]):
args.append(0)
print(args)
append() #[0]
append([1]) #[1,0]
append() #[0,0],此时使用的列表还是第一次调用的args，因此在原有基础上再追加一个元素0。
'''
args:[]
id(args):-->4363806792
[0]
args:[1]
id(args):-->4363805384
[1, 0]
args:[0]
id(args):-->4363805384
[0, 0]
'''
修改以上函数：
def append(args=[]):
if len(args)==0:
args = []
args.append(0)
print(args)
append() #[0]
append([1]) #[1,0]
append() #[0]
- 关键参数：关键参数必须放在位置参数之后。
def count(x,y,z):
print(x,y,z)
count(2,y=3,z=6) #2 3 6
count(1,z=3,y=2) #1 2 3
# count(z=1,2,3) #错误，SyntaxError: positional argument follows keyword argument
- 可变长度参数：
*args：会把传入的参数变成一个元组形式
**kwargs：会把传入参数变成一个字典形式
*必须写在**的前面
def count(*args):
print(args) #(1, 'a', [1, 2, 3], {'name': 'zhangsan'})
print(type(args)) #<class 'tuple'>
count(1,'a',[1,2,3],{'name':'zhangsan'})
def info(**kargs):
print(kargs) #{'name': 'zhangsan', 'age': 18, 'score': 'A'}
print(type(kargs)) #<class 'dict'>
info(name='zhangsan',age=18,score='A')
- 高阶函数
一个函数的参数为另一个函数。
def func(x):
return x*2
def func2(x,y,f):
return f(x) + f(y)
print(func2(3,2,func)) #10
2.3 嵌套函数
嵌套函数就是指在函数的内部调用其他函数。函数的嵌套层数不宜过多，会造成代码的可读性差、不易维护等问题。一般函数的嵌套调用应控制在3层以内。
- 函数嵌套：
def sum(x,y):
return x+y
def sub(x,y):
return x-y
def func(x,y):
return sum(x,y)*sub(x,y)
print(func(5,2))
- 函数内部定义函数：
def func():
x = 5
y = 2
m = 3
n = 1
def sum(a,b):
return a+b
def sub(a,b):
return a-b
return sum(x,y)*sub(m,n)
print(func())
- 内部函数引用外部函数的变量：
def func():
x = 5
y = 2
m = 3
n = 1
def sum():
return x+y
def sub():
return m-n
return sum()*sub()
print(func())
2.4 递归函数
递归函数可以在函数主体内直接或间接地调用自己，即函数的嵌套是函数本身。递归是一种程序设计方法，使用递归可以减少重复的代码，使程序变得简洁。
递归分为两个阶段：递推和回归。
第一阶段：递归函数在内部调用自己。每一次函数调用又重新开始执行此函数的代码，直到某一级递归程序结束。
第二阶段：递归函数从后往前返回。递归函数从最后一级开始返回，一直返回到第一次调用的函数体内。即递归逐级调用完毕后，再按照相反的顺序逐级返回。
递归函数需要编写递归结束的条件，否则就是死循环，一般通过判断语句来结束程序。
计算阶乘：
def func(n):
i=0
if n>1:
i=n
n *= func(n-1)
print('%s的阶乘:%s'%(i,n))
return n
func(5)
'''
2的阶乘:2
3的阶乘:6
4的阶乘:24
5的阶乘:120
'''
2.5 lambda函数
lambda函数用于创建一个匿名函数，函数名和标识符进行绑定。使用lambda函数可以返回一些简单的运算结果。的lambda也成为表达式，lambda中只能使用表达式，不能使用判断、循环等多重语句。
格式：通常把lambda赋值给一个变量
#赋值 func = lambda 变量1,变量2...:表达式 #调用 func()
这样就把lambda和变量func绑定在一起了，变量func的名称就是函数名。lambda函数可以消除内部函数。
def func():
x = 1
y = 2
m = 3
n = 4
sum = lambda x,y:x+y
print(sum)
sub = lambda m,n:m-n
print(sub)
return sum(x,y) * sub(m,n)
print(func())
2.6 Generator函数
生成器(Generator)的作用是一次产生一个数据项，并把数据项输出。Generator函数可以用在for循环中遍历。Generator函数每次返回一个数据项的特性，使得迭代器的性能更佳。
格式：
def 函数名(参数列表): ... yield 表达式
Generator在函数体内使用yield生成数据项，可以被for循环遍历，并可以通过next()方法获得yield生成的数据项。
def func(n):
for i in range(n):
yield i
r = func(3)
#使用__next__方法输出
print(r.__next__())
print(r.__next__())
print(r.__next__())
# print(r.__next__()) #报错：StopIteration
#类似for循环
for i in range(3):
print(i)
yiled与return的返回值和执行原理不同。
yield生成值并不会中止程序的执行，返回值后程序继续往后执行。
return返回值后，程序将中止执行。
#yield与return区别
def func(n):
for i in range(n):
return i
def func2(n):
for i in range(n):
yield i
print('#return演示:%s'%func(3)) #0
r = func2(3)
print('yield演示:')
print(r.__next__()) #0
print(r.__next__()) #1
print(r.__next__()) #2
Generator函数每次只返回一个数据项，占用更少的内存。每次生成的数据都要记录当前的状态，便于下一次生成数据。数据的访问是通过next()方法实现。当访问越界时会抛出StopIten异常。
当程序需要较高的性能或一次只需一个值进行处理时，使用Generator函数。