Python自定义函数、模块

Python函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

定义一个函数

你可以定义一个由自己想要功能的函数，以下是简单的规则：

·      函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。

·      任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。

·      函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。

·      函数内容（函数体）以冒号起始，并且缩进。

·      return [表达式] 结束函数，选择性地返回一个值给调用方。不带return语句的相当于返回 None。

语法

def functionname( parameters ):
   "函数_文档字符串"
  function_suite
   return[expression]

默认情况下，参数值和参数名称是按函数声明中定义的的顺序匹配起来的。

实例

以下为一个简单的Python函数，它将一个字符串作为传入参数，再打印到标准显示设备上。

def printme( str ):
   "打印传入的字符串到标准显示设备上"
   print str
   return

实例：

实例：

函数调用

定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。

这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。

如下实例调用了printme（）函数：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 定义函数
def printme( str ):
   "打印任何传入的字符串"
   print str;
   return;
 
# 调用函数
printme("我要调用用户自定义函数!");
printme("再次调用同一函数");

以上实例输出结果：

我要调用用户自定义函数!

再次调用同一函数

 

参数

以下是调用函数时可使用的正式参数类型：

·      必备参数

·      关键字参数

·      默认参数

·      不定长参数

 

必备参数

必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

调用printme()函数，你必须传入一个参数，不然会出现语法错误：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print str;
   return;
 
#调用printme函数
printme();
以上实例输出结果：
Traceback(most recent call last):
  File"test.py", line 11,in<module>
   printme();
TypeError: printme() takes exactly 1 argument (0 given)

关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。

使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

以下实例在函数 printme() 调用时使用参数名：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print str;
   return;
 
#调用printme函数
printme( str ="My string");
以上实例输出结果：
Mystring

下例能将关键字参数顺序不重要展示得更清楚：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
#可写函数说明
def printinfo( name, age ):
   "打印任何传入的字符串"
   print"Name: ", name;
   print"Age ", age;
   return;
 
#调用printinfo函数
printinfo( age=50, name="miki");
以上实例输出结果：
Name:  miki
Age  50

默认参数

调用函数时，默认参数的值如果没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
#可写函数说明
def printinfo( name, age =35):
   "打印任何传入的字符串"
   print"Name: ", name;
   print"Age ", age;
   return;
 
#调用printinfo函数
printinfo( age=50, name="miki");
printinfo( name="miki");
以上实例输出结果：
Name:  miki
Age  50
Name:  miki
Age  35

不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。基本语法如下：

def functionname([formal_args,]*var_args_tuple ):
   "函数_文档字符串"
  function_suite
   return[expression]

加了星号（*）的变量名会存放所有未命名的变量参数。选择不多传参数也可。如下实例：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 可写函数说明
def printinfo( arg1,*vartuple ):
   "打印任何传入的参数"
   print"输出: "
   print arg1
   forvarin vartuple:
      printvar
   return;
 
# 调用printinfo 函数
printinfo(10);
printinfo(70,60,50);

以上实例输出结果：
输出:
10
输出:
70
60
50

 

实例：

 

实例：

def sayhi(**info):
    if info:
        print info
    else:
        print '需要参数'
sayhi(name='alice',age='16')

匿名函数

python 使用 lambda 来创建匿名函数。

·      lambda只是一个表达式，函数体比def简单很多。

·      lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

·      lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。

·      虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

语法

lambda函数的语法只包含一个语句，如下：

lambda[arg1 [,arg2,.....argn]]:expression

如下实例：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 可写函数说明
sum =lambda arg1, arg2: arg1 + arg2;
 
# 调用sum函数
print"相加后的值为 : ", sum(10,20)
print"相加后的值为 : ", sum(20,20)
以上实例输出结果：
相加后的值为:  30
相加后的值为:  40

实例：

add = lambda x,y : x + y   # 匿名函数，适合不太复杂的公式计算  直接返回结果
print add(5,10)

li = map(lambda x:x*2 ,range(10))  # 把序列每个值当成参数传给函数，再把函数返回值放到列表里返回
for i in li:
    print i

 

return语句

return语句[表达式]退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值，下例便告诉你怎么做：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 可写函数说明
def sum( arg1, arg2 ):
   # 返回2个参数的和."
  total = arg1 + arg2
   print"函数内 : ", total
   return total;
 
# 调用sum函数
total = sum(10,20);
以上实例输出结果：
函数内:  30

变量作用域

一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下：

·      全局变量

·      局部变量

全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。如下实例：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
total =0;# 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
   #返回2个参数的和."
  total = arg1 + arg2;# total在这里是局部变量.
   print"函数内是局部变量 : ", total
   return total;
 
#调用sum函数
sum(10,20);
print"函数外是全局变量 : ", total 
以上实例输出结果：
函数内是局部变量:  30
函数外是全局变量:  0

 

实例：函数内部改变参数值，并不影响全局变量（如果非要改变则用global关键

Global关键字：

 

Python模块

模块让你能够有逻辑地组织你的Python代码段。

把相关的代码分配到一个模块里能让你的代码更好用，更易懂。

模块也是Python对象，具有随机的名字属性用来绑定或引用。

简单地说，模块就是一个保存了Python代码的文件。模块能定义函数，类和变量。模块里也能包含可执行的代码。

例子

一个叫做aname的模块里的Python代码一般都能在一个叫aname.py的文件中找到。下例是个简单的模块support.py。

def print_func( par ):
   print"Hello : ", par
   return

 

import语句

想使用Python源文件，只需在另一个源文件里执行import语句，语法如下：

import module1[, module2[,... moduleN]

当解释器遇到import语句，如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。如想要导入模块support.py，需要把命令放在脚本的顶端：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 导入模块
import support
 
# 现在可以调用模块里包含的函数了
support.print_func("Zara")
以上实例输出结果：
Hello:Zara

一个模块只会被导入一次，不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。

From…import语句

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中。语法如下：

from modname import name1[, name2[,... nameN]]

例如，要导入模块fib的fibonacci函数，使用如下语句：

from fib import fibonacci

这个声明不会把整个fib模块导入到当前的命名空间中，它只会将fib里的fibonacci单个引入到执行这个声明的模块的全局符号表。

From…import*语句

把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：

from modname import*

这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。

 

 

dir()函数

dir()函数一个排好序的字符串列表，内容是一个模块里定义过的名字。

返回的列表容纳了在一个模块里定义的所有模块，变量和函数。如下一个简单的实例：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 导入内置math模块
import math
 
content = dir(math)
 
print content;

以上实例输出结果：

['__doc__','__file__','__name__','acos','asin','atan',
'atan2','ceil','cos','cosh','degrees','e','exp',
'fabs','floor','fmod','frexp','hypot','ldexp','log',
'log10','modf','pi','pow','radians','sin','sinh',
'sqrt','tan','tanh']

在这里，特殊字符串变量__name__指向模块的名字，__file__指向该模块的导入文件名。

 

Python中的包

包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的Python的应用环境。

考虑一个在Phone目录下的pots.py文件。这个文件有如下源代码：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
defPots():
   print"I'm Pots Phone"

同样地，我们有另外两个保存了不同函数的文件：

·      Phone/Isdn.py 含有函数Isdn()

·      Phone/G3.py 含有函数G3()

现在，在Phone目录下创建file __init__.py：

·      Phone/__init__.py

当你导入Phone时，为了能够使用所有函数，你需要在__init__.py里使用显式的导入语句，如下：

fromPotsimportPots
fromIsdnimportIsdn
from G3 import G3

当你把这些代码添加到__init__.py之后，导入Phone包的时候这些类就全都是可用的了。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 导入 Phone 包
importPhone
 
Phone.Pots()
Phone.Isdn()
Phone.G3()
以上实例输出结果：
I'm Pots Phone
I'm 3GPhone
I'm ISDN Phone

如上，为了举例，我们只在每个文件里放置了一个函数，但其实你可以放置许多函数。