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 ‘\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