第六期Python中的函数与模块

MidYouth

1.python中的函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

定义一个函数

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

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

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

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

函数调用

定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。
这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。
如下实例调用了printme（）函数：

  1. # 定义函数
  2. def printme( str ):
  3.    "打印任何传入的字符串"
  4.    print str;
  5.    return;
  8. # 调用函数
  9. printme("我要调用用户自定义函数!");
  10. printme("再次调用同一函数");

在 python 中，类型属于对象，变量是没有类型的

  1. a=[1,2,3]
  3. a="Runoob"

以上代码中，[1,2,3] 是 List 类型，"Runoob" 是 String 类型，而变量a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是 List 类型对象，也可以指向 String 类型对象。

参数

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

  1. 位置参数
  2. 关键字参数
  3. 默认参数
  4. 不定长参数

位置参数

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

关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

  1. def printinfo( name, age ):
  2.    "打印任何传入的字符串"
  3.    print "Name: ", name
  4.    print "Age ", age
  5.    return
  7. #调用printinfo函数
  8. printinfo( age=50, name="miki" )

默认参数

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

  1. def printinfo( name, age = 35 ):
  2.    "打印任何传入的字符串"
  3.    print "Name: ", name
  4.    print "Age ", age
  5.    return;
  7. #调用printinfo函数
  8. printinfo( age=50, name="miki" )
  9. printinfo( name="miki" )

不定长参数（选学）

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

  1. def printinfo( arg1, *vartuple ):
  2.    "打印任何传入的参数"
  3.    print "输出: "
  4.    print arg1
  5.    for var in vartuple:
  6.       print var
  7.    return;
  9. # 调用printinfo 函数
  10. printinfo( 10 );
  11. printinfo( 70, 60, 50 );

以上实例的输出结果：

  2. 输出:
  3. 10
  4. 输出:
  5. 70
  6. 60
  7. 50

Return 语句

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

  1. def sum( arg1, arg2 ):
  2.    # 返回2个参数的和."
  3.    total = arg1 + arg2
  4.    print "函数内 : ", total
  5.    return total;
  7. # 调用sum函数
  8. total = sum( 10, 20 );

以下示例结果：

  1. 函数内: 30

变量作用域(选学）

一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。
变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。

全局变量
局部变量

全局变量和局部变量（选学）

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

2.python中的模块

Python 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了Python对象定义和Python语句。模块让你能够有逻辑地组织你的Python代码段。模块能定义函数，类和变量，模块里也能包含可执行的代码。

import语句

引入模块

模块定义好后，我们可以使用 import 语句来引入模块，语法如下：
import ...(模块名）

比如要引用模块 math，就可以在文件最开始的地方用 import math 来引入。在调用 math 模块中的函数时，必须这样引用：

模块名.函数名

例

  1. # 导入模块
  2. import support
  4. # 现在可以调用模块里包含的函数了
  5. support.print_func("Runoob")

以上实例输出结果：

Hello : Runoob

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

from…import 语句

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

from (模块名）import （模块部分）

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

from fib import fibonacci

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

编写自己的模块

编写你自己的模块很简单，这其实就是你一直在做的事情！这是因为每一个 Python 程序同时 也是一个模块。你只需要保证它以 .py 为扩展名即可。下面的案例会作出清晰的解释。

案例（保存为 mymodule.py ）：

  1. def say_hi():               
  2. print('Hi,  this is mymodule speaking.')
  3. __version__ =   '0.1'

上方所呈现的就是一个简单的模块。正如你所看见的，与我们一般所使用的 Python 的程序相 比其实并没有什么特殊的区别。我们接下来将看到如何在其它 Python 程序中使用这一模块。
要记住该模块应该放置于与其它我们即将导入这一模块的程序相同的目录下，或者是放置在 sys.path 所列出的其中一个目录下。

另一个模块（保存为 mymodule_demo.py ）：

  1. import  mymodule
  2. mymodule.say_hi() 
  3. print('Version',    mymodule.__version__)

输出

Hi, this is mymodule speaking. Version 0.1

上述过程是怎么来运行的呢？
我们是在 mymodule_demo.py文件中引入mymodule模块，通过模块.函数调用其中的say_hi函数及其模块中的version变量

以上就是我们今天所涉及到的函数与模块知识