Python模块与函数

　　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函数。