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
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')
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
'''