Python学习笔记4（函数与模块）

1.Python程序的结构

Python的程序由包(package)、模块(module)和函数组成。

模块是处理一类问题的集合，由函数和类组成。

包是由一系列模块组成的集合。包是一个完成特定任务的工具箱。

2.函数

2.1函数的定义

def sayHello():
print 'Hello World!'        # block belonging to the function
sayHello()

2.2函数的参数
Python中任何东西都是对象，所以参数只支持引用传递的方式。Python通过名称绑定的机制，把实际参数的值和形式参数的名称绑在一起。即形参与实参指向内存中同一个储存空间。

def arithmetic (x = 1, y =  1, operator = "+"):
result = {
"+" : x + y,
"-" : x - y,
"*" : x * y,
"/" : x / y
}
return result.get(operator)

print (arithmetic(1,2))
print (arithmetic(y = 2, operator = "-")
print (arithmetic(y = 3, x = 1, operator = "*")       #  使用赋值表达式传递参数，可以颠倒参数列表的顺序

# 列表作为参数
def arithmetic (args = [], operator = "+"):
x = args[0]
y = args[1]
result = {
"+" : x + y,
"-" : x - y,
"*" : x * y,
"/" : x / y
}
return result.get(operator)

print (arithmetic([1,2]))

#  使用默认参数出现预期外结果
def append(args = []):
args.append(0)
print (args)

append()                        # [0]
append([1])                   # [1,0]
append()                        # [0,0] , 使用的仍是第一次调用的args

# 避免重复问题
def append(args = []):
if len(args) <= 0                 # 若args中没有元素，将其列表置空
args = []
args.append(0)
print(args)

append()                        # [0]
append([1])                   # [1,0]
append()                        # [0]

#  传递可变参数
def func(*args):                  #  传入的实参被“打包”到一个args元组中
print args
func(1,2,3)

# 传递可变参数——字典
def search (*t, **d):             #  在形参前加"**"，可以引用一个字典
keys = d.keys()
values = d.values()
print (keys)
print (values)
for args in t:
for key in keys:
if args == key:
print ("find：", d[key])

search("one", "three", one = "1", two = "2", three = "3")

2.3函数的返回值
返回值用return语句，其后可为变量或表达式。Python中即使函数无返回值，依旧可以获得返回值None。或者return不带任何参数时，也返回None。

# return返回多个值，打包到元组内
def func(x,y,z):
l = [x,y,z]
l.reverse()
numbers = tuple(l)                 # a,b,c = tuple(l)
return numbers                      # return a,b,c

x,y,z = func(0,1,2)
print (x,y,z)

2.4函数的嵌套
Python不仅支持函数体内嵌套，还支持函数定义的嵌套。

#  在函数体内部定义函数
def func():
x=1
y=2
m=3
n=4
def sun(a,b):
return a+b
def sub(a,b):;
return a-b
return sum(x,y) * sub(m,n)

print(func())

#  嵌套函数，直接使用外层函数的变量
def func():
x=1
y=2
m=3
n=4
def sun():
return x+y
def sub():;
return m-n
return sum() * sub()

print(func())

PS:尽量不要在函数内部定义函数，不便于程序维护
2.5递归函数

#  计算阶乘
def refunc(n):
i=1
if n > 1:
i = n
n = n * refunc(n-1)
print ("%d! =" %i,n)
return n

refunc(5)

# output:
1! = 1
2! = 2
3! = 6
4! = 24
5! = 120

#  使用reduce计算阶乘
From functools import reduce
print ("5! =", reduce(lambda x, y: x * y, range(1,6)))

2.6lambda函数
用于创建一个匿名函数，函数名未和标识符进行绑定。使用lambda函数可以返回一些简单的运算结果。通常把lambda赋值给一个变量，该变量就可以作为函数使用。

func = lambda 变量1,变量2,... : 表达式

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

# lambda的函数用法
print ( (lambda x : -x) (-2))        #给x赋值-2

PS：lambda中只能使用表达式，不能使用判断、循环等多重语句。
2.7Generator函数

生成器（Generator）的作用是一次产生一个数据项，并把数据项输出。Generator函数可以用在for循环中遍历。Generator函数每次返回一个数据项的特性，使得迭代器的性能更佳。

# 定义Generator函数
def func(n):
for i in range(n):
yield i
# 在for循环中输出
for i in func(3):
print (i)                                           # 0 1 2
# 使用next()输出
r = func(3)
print (r.next())                                    # 0
print (r.next())                                    # 1
print (r.next())                                    # 2
print (r.next())                                    # 已无数据生成，抛出异常StopIteration

# yield 与 return的区别
def func(n):
for i in range(n):
return i                                          # return 函数运行到此为止
def func2(n):
for i in range(n):
yield i                                            # 循环生成n个数，不会被终止

print (func(3))                                        # 0
f = func2(3)
print (f)                                                  #  返回函数func2的地址
print (f.next())                                        # 0
print (f.next())                                        # 1

Generator函数依次只赶回一个数据项，占用更少的内存。每次生成数据都要记录当前的状态，便于生成下一次数据。数据的访问通过next()实现。当 访问越界时，抛出异常StopIteration。

2.8global语句

如果你想要为一个定义在函数外的变量赋值，那么你就得告诉Python这个变量名不是局部的，而是 全局 的。我们使用global语句完成这一功能。没有global语句，是不可能为定义在函数外的变量赋值的。

def func():
global x
print 'x is', x                                     # 50
x = 2
print 'Changed local x to', x                # 2
x = 50
func()
print 'Value of x is', x                             # 2

3.模块

3.1使用sys模块

import sys                                  # from sys import argv
print 'The command line arguments are:'
for i in sys.argv:
print i
print '\n\nThe PYTHONPATH is', sys.path,  '\n'

# output
The command line arguments are:
using_sys.py
we
are
arguments

The PYTHONPATH is ['/home/swaroop/byte/code',
'/usr/lib/python23.zip', '/usr/lib/python2.3',
'/usr/lib/python2.3/plat-linux2', '/usr/lib/python2.3/lib-tk', '/usr/lib/python2.3/libdynload', '/usr/lib/python2.3/site-
packages', '/usr/lib/python2.3/site-packages/gtk-2.0']

Python中的import语句可以置于程序的任何位置。
sys模块包含了与Python解释器和它的环境有关的函数。

sys.argv变量是一个字符串的列表 。特别地，sys.argv包含了命令行参数的列表，即使用命令行传递给你的程序的参数。

这里，当我们执行python using_sys.py we are arguments的时候，我们使用python命令 运行using_sys.py模块，后面跟着的内容被作为参数传递给程序。Python为我们把它存储 在sys.argv变量中。

脚本的名称总是sys.argv列表的第一个参数。所以，在这里，'using_sys.py'是sys.argv[0]、'we'是sys.argv[1]、'are'是sys.argv[2]以 及'arguments'是sys.argv[3]。

sys.path包含输入模块的目录名列表。我们可以观察到sys.path的第一个字符串是空的——这个空的字符串表示当前目录也是sys.path的一部分，这与PYTHONPATH环境变量是相同的。这意味着你可以直接输入位于当前目录的模块。否则，你得把你的模块放在sys.path所列的目录之一。

3.2.pyc文件

使输入模块更加快的方法：

创建字节编译的文件 ，这些文件以.pyc作为扩展名。字节编译的文件与Python变换程序的中间状态有关。当你在下次从别的程序输入这个模块的时候，.pyc文件是十分有用的——它会快得多，因为一部分输入模块所需的处理已经完成了。另外，这些 字节编译的文件也是与平台无关的。

3.3模块的__name__

当一个模块被第一次输入的时候，这个模块的主块将被运行。假如我们只想在程序本身被使用的时候运行主块，而在它被别的模块输入的时候不运行主块，这可以通过模块的 __name__属性完成。

_name_用于判断当前模块是否是程序的入口，如果当前程序正在被使用，_name_的值为"_main_"。

if __name__ == '__main__':
print 'This program is being run by itself'
else:
print 'I am being imported from another module'

# output
This program is being run by itself
$ python
>>> import using_name
I am being imported from another module

每个Python模块都有它的__name__，如果它是'__main__'，这说明这个模块被用户单独运行，我们 可以进行相应的恰当操作。

3.4模块的创建

模块把一组相关的函数或代码组织到一个文件中。一个文件即是一个模块。模块由代码、函数或类组成。创建一个名为myModule.py的文件，即定义了一个名为myModule的模块。

#  自定义模块
def func():
print ("MyModule.func()" )

class MyClass:
def myFunc(self):
print ("MyModule.MyClass.myFunc()")

#  在myModule.py所在目录下创建一个call_myModule.py的文件。在该文件中调用myModule模块的函数和类

import myModule
myModule.func()
myClass = myModule.MyClass()
myClass.myFunc()

另一个例子：

# Filename: mymodule.py
def sayhi():
print 'Hi, this is mymodule speaking.'

version = '0.1'

#  调用mymodule模板
import mymodule                                             #  from mymodule import sayhi, version
mymodule.sayhi()
print 'Version', mymodule.version

# output
$ python mymodule_demo.py
Hi, this is mymodule speaking.
Version 0.1

3.5模块的内置函数

Python提供了一个内联模板buildin。内联模板定义了一些开发中经常使用的函数，利用这些函数可以实现数据类型的转换、数据的计算、序列的处理等功能。

filter()

对某个序列做过滤处理，判断自定义函数的参数返回的结果是否为真来过滤，并一次性返回处理结果。

# 声明
class filter(object)
filter(function or None, iterable)  --> filter object

# 功能
def func(x):
if x > 0:
return x

#  使用range()生成待处理的列表，然后把该列表的值依次传入func(),func()返回结果给filter()，最后将结果yield成一个iterable对象返回，依次遍历
#  output <filter object at 0x1022b2750>
#  直接打印出filter对象。最后一行将其转换为列表
print ( filter (func,range(-9,10)) )                   # 调用filter函数，返回filter对象
print ( list(filter(func,range(-9,10)))               # 将filter对象转换为列表

filter()中的过滤函数func()的参数不能为空。否则，没有可以存储sequence元素的变量，func()也不能处理过滤

reduce()

实现连续处理的功能，存在于functools模块中。

#  声明
reduce(func,sequence[, initial])  -> value

# func()是自定义函数，在其中实现对参数sequence即待处理序列的连续操作
# 参数initial可以省略，若不为空，则initial的值首先传入func()进行计算。若sequence为空，则对initial的值进行处理
# reduce()返回值为func()计算后的结果

#  功能
def sun(x,y):
return x+y
from functools import reduce
print  (reduce(sum,range(0,10)))               # 0加到9，结果45
print  (reduce(sum,range(0,10),10))          # 10加0加到9，结果55
print  (reduce(sum,range(0,0),10))            # 结果10

如果用reduce()进行累计计算，必须在sum中定义两个参数，分别对应加法运算符两侧的操作数。

map()

可对多个序列的每个元素都执行相同的操作，并返回一个map对象。

#  声明
class map(object)
map(func, *iterables)  --> map object

# func自定义函数，实现对每个元素的操作
# iterables是待处理序列，其个数可以是多个
# map返回值为处理后的列表

若map中提供多个序列，则每个序列中元素一一对应计算。若长度不等，短的后补None
3.6dir()函数

你可以使用内建的dir函数来列出模块定义的标识符。标识符有函数、类和变量。

当你为dir()提供一个模块名的时候，它返回模块定义的名称列表。如果不提供参数，它返回当前模块中定义的名称列表。

import sys
dir(sys)             # 输出sys模块上的属性列表。 ['__displayhook__', '__doc__', '__excepthook__', '__name__',
'__stderr__', '__stdin__', '__stdout__', '_getframe', 'api_version',
'argv', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',
'copyright', 'displayhook', 'exc_clear', 'exc_info', 'exc_type', 'excepthook',
'exec_prefix', 'executable', 'exit', 'getcheckinterval', 'getdefaultencoding',
'getdlopenflags', 'getfilesystemencoding', 'getrecursionlimit', 'getrefcount',
'hexversion', 'maxint', 'maxunicode', 'meta_path','modules', 'path',
'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1', 'ps2',
'setcheckinterval', 'setdlopenflags', 'setprofile', 'setrecursionlimit', 'settrace',
'stderr', 'stdin', 'stdout', 'version', 'version_info', 'warnoptions']

dir()                 # 返回当前模块的属性列表，输入的模块同样是列表的一部分。 ['__builtins__', '__doc__', '__name__', 'sys']
a = 5            # create a new variable 'a'
dir()
['__builtins__', '__doc__', '__name__', 'a', 'sys']
del a           # delete/remove a name
dir()
['__builtins__', '__doc__', '__name__', 'sys']

为了观察dir的作用，定义一个新的变量a并且给它赋一个值，检验dir，在列表中增加了以上相同的值。

我们使用del语句删除当前模块中的变量/属性，这个变化再一次反映在dir的输出中。

PS:del语句在运行后被用来 删除一个变量/名称。在这个例子中，del a，你将无 法再使用变量a——它就好像从来没有存在过一样。

3.7自定义包

包就是一个至少包含_init_.py文件的文件夹。包为了实现程序的重用，把实现一个常用功能的代码组合到一个包中，调用包提供的服务从而实现重用。

# 包的_init_.py程序
if _name_ == '_main_':
print ('作为主程序运行')
else:
print ('pack初始化')

# 包的myModule模块
def func():
print ("pack.myModule.func()")

if _name_ == '_main_':
print ('myModule作为主程序运行')
else:
print ('pack被另一模块调用)

#  main模板调用pack中的函数
from pack import myModule

myModule.func()

# output:
pack初始化
myModule被另一个模板调用

pack.myModule.func()

_init_.py也可用于提供当前包的模块列表。eg.在pack包的_init_.py文件前添加一行代码

_all_ = ["myModule"]

_all_用于记录当前pack包所含的模板。其中方括号中的内容是模板名的列表，如果模块数量超过2个，使用逗号分开。

这样就可以在main模板中一次导入pack包中的所有模块。

from pack import *

myModule.func()

# 首先执行pack包的_init_.py文件，然后在属性中查找pack包含有的模块。如果pack包的_init_.py文件不适用_all_属性记录模块名，main模块调用时将不能识别myModule模块。Python将提示如下错误：
NameError:name 'myModule' is not defend