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)
1 # 传递可变参数——字典 2 def search (*t, **d): # 在形参前加"**"，可以引用一个字典 3 keys = d.keys() 4 values = d.values() 5 print (keys) 6 print (values) 7 for args in t: 8 for key in keys: 9 if args == key: 10 print ("find：", d[key]) 11 12 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 ' The PYTHONPATH is', sys.path, ' ' # 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