7天入门Python 5 — 函数、模块及异常

朴灿烈づ我的快乐病毒、 2023-06-09 11:24 23阅读 0赞

> 专栏自述：随着这几年机器学习火爆，楼主写了Java好多年，python其实也会写，但是缺乏系统性梳理，所以搞一个python栏目，系统性梳理的同时也把python的知识做一些梳理，欢迎查阅，欢迎一起学习python

传送门：

*  [7天入门Python 1 — Python本地安装][7_Python 1 _ Python]
 *  [7天入门Python 2 — Python认识][7_Python 2 _ Python]
 *  [7天入门Python 3 — Python对象属性及核心数据类型][7_Python 3 _ Python]
 *  [7天入门Python 4 — 运算符、条件及循环][7_Python 4 _]
 *  [7天入门Python 5 — 函数、模块及异常][7_Python 5 _]
 *  [7天入门Python 6 — 输入输出、文件及OS][7_Python 6 _ _OS]

## Python函数 ##

### 声明函数 ###

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

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

**语法：**

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

**实例：**

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

### 函数调用 ###

**实例：**

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

### 参数传递 ###

**可更改(mutable)与不可更改(immutable)对象**

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

*  **不可变类型：**变量赋值 **a=5** 后再赋值 **a=10**，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
 *  **可变类型：**变量赋值 **la=\[1,2,3,4\]** 后再赋值 **la\[2\]=5** 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。在 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

### 参数 ###

**必备参数**

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

错误调用实例：

#!/usr/bin/python
    # -*- coding: UTF-8 -*-
     
    #可写函数说明
    def printme( str ):
       "打印任何传入的字符串"
       print str;
       return;
     
    #调用printme函数，这是错误用法
    printme();

**关键字参数**

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

实例：

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

**默认参数**

调用函数时，默认参数的值如果没有传入，则被认为是默认值。

实例：

#!/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" );

**不定长参数**

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

实例：

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

### 匿名函数 ###

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

*  lambda只是一个表达式，函数体比def简单很多。
 *  lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
 *  lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
 *  虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

**语法：**

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 )

### Python内置函数 ###

请查看 python官方文档：[https://docs.python.org/zh-cn/3.6/library/functions.html][https_docs.python.org_zh-cn_3.6_library_functions.html]

## 模块 ##

Python 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。

### import 语句 ###

**语法：**

# 引入模块
    import module1[, module2[,... moduleN]]

**实例：**

#!/usr/bin/python
    # -*- coding: UTF-8 -*-
     
    # 导入模块
    import support
     
    # 现在可以调用模块里包含的函数了
    support.print_func("Runoob")

### from ... import 语句 ###

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

**语法：**

# 从模块 modname 引入方法/变量等命名空间到当前
    from modname import name1[, name2[, ... nameN]]

### from ... import \* 语句 ###

把一个模块的所有内容全都导入到当前的命名空间也是可行的

# 从模块 modname 引入所有方法变量的命名空间到当前
    from modname import *

## Python包 ##

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

简单来说，包就是文件夹，但该文件夹下必须存在 \_\_init\_\_.py 文件, 该文件的内容可以为空。**\_\_init\_\_.py** 用于标识当前文件夹是一个包。

**实例：**

#文件结构如下
    test.py       #test.py 为测试调用包的代码
    package_runoob
    |-- __init__.py
    |-- runoob1.py
    |-- runoob2.py

#!/usr/bin/python
    # -*- coding: UTF-8 -*-
     
    def runoob1():
       print "I'm in runoob1"
    
    # package_runoob/runoob1.py 源码

#!/usr/bin/python
    # -*- coding: UTF-8 -*-
     
    def runoob2():
       print "I'm in runoob2"
    
    # package_runoob/runoob2.py 源码

#!/usr/bin/python
    # -*- coding: UTF-8 -*-
     
    if __name__ == '__main__':
        print '作为主程序运行'
    else:
        print 'package_runoob 初始化'
    
    # package_runoob/__init__.py 源码

#!/usr/bin/python
    # -*- coding: UTF-8 -*-
     
    # 导入 Phone 包
    from package_runoob.runoob1 import runoob1
    from package_runoob.runoob2 import runoob2
     
    runoob1()
    runoob2()
    
    # test.py 源码

**输出结果：**

package_runoob 初始化
    I'm in runoob1
    I'm in runoob2

## 异常处理 ##

python提供了两个非常重要的功能（异常和断言）来处理python程序在运行中出现的异常和错误。你可以使用该功能来调试python程序。

### Python标准异常 ###

<table> 
 <tbody> 
  <tr> 
   <th>异常名称</th> 
   <th>描述</th> 
  </tr> 
  <tr> 
   <td>BaseException</td> 
   <td>所有异常的基类</td> 
  </tr> 
  <tr> 
   <td>SystemExit</td> 
   <td>解释器请求退出</td> 
  </tr> 
  <tr> 
   <td>KeyboardInterrupt</td> 
   <td>用户中断执行(通常是输入^C)</td> 
  </tr> 
  <tr> 
   <td>Exception</td> 
   <td>常规错误的基类</td> 
  </tr> 
  <tr> 
   <td>StopIteration</td> 
   <td>迭代器没有更多的值</td> 
  </tr> 
  <tr> 
   <td>GeneratorExit</td> 
   <td>生成器(generator)发生异常来通知退出</td> 
  </tr> 
  <tr> 
   <td>StandardError</td> 
   <td>所有的内建标准异常的基类</td> 
  </tr> 
  <tr> 
   <td>ArithmeticError</td> 
   <td>所有数值计算错误的基类</td> 
  </tr> 
  <tr> 
   <td>FloatingPointError</td> 
   <td>浮点计算错误</td> 
  </tr> 
  <tr> 
   <td>OverflowError</td> 
   <td>数值运算超出最大限制</td> 
  </tr> 
  <tr> 
   <td>ZeroDivisionError</td> 
   <td>除(或取模)零 (所有数据类型)</td> 
  </tr> 
  <tr> 
   <td>AssertionError</td> 
   <td>断言语句失败</td> 
  </tr> 
  <tr> 
   <td>AttributeError</td> 
   <td>对象没有这个属性</td> 
  </tr> 
  <tr> 
   <td>EOFError</td> 
   <td>没有内建输入,到达EOF 标记</td> 
  </tr> 
  <tr> 
   <td>EnvironmentError</td> 
   <td>操作系统错误的基类</td> 
  </tr> 
  <tr> 
   <td>IOError</td> 
   <td>输入/输出操作失败</td> 
  </tr> 
  <tr> 
   <td>OSError</td> 
   <td>操作系统错误</td> 
  </tr> 
  <tr> 
   <td>WindowsError</td> 
   <td>系统调用失败</td> 
  </tr> 
  <tr> 
   <td>ImportError</td> 
   <td>导入模块/对象失败</td> 
  </tr> 
  <tr> 
   <td>LookupError</td> 
   <td>无效数据查询的基类</td> 
  </tr> 
  <tr> 
   <td>IndexError</td> 
   <td>序列中没有此索引(index)</td> 
  </tr> 
  <tr> 
   <td>KeyError</td> 
   <td>映射中没有这个键</td> 
  </tr> 
  <tr> 
   <td>MemoryError</td> 
   <td>内存溢出错误(对于Python 解释器不是致命的)</td> 
  </tr> 
  <tr> 
   <td>NameError</td> 
   <td>未声明/初始化对象 (没有属性)</td> 
  </tr> 
  <tr> 
   <td>UnboundLocalError</td> 
   <td>访问未初始化的本地变量</td> 
  </tr> 
  <tr> 
   <td>ReferenceError</td> 
   <td>弱引用(Weak reference)试图访问已经垃圾回收了的对象</td> 
  </tr> 
  <tr> 
   <td>RuntimeError</td> 
   <td>一般的运行时错误</td> 
  </tr> 
  <tr> 
   <td>NotImplementedError</td> 
   <td>尚未实现的方法</td> 
  </tr> 
  <tr> 
   <td>SyntaxError</td> 
   <td>Python 语法错误</td> 
  </tr> 
  <tr> 
   <td>IndentationError</td> 
   <td>缩进错误</td> 
  </tr> 
  <tr> 
   <td>TabError</td> 
   <td>Tab 和空格混用</td> 
  </tr> 
  <tr> 
   <td>SystemError</td> 
   <td>一般的解释器系统错误</td> 
  </tr> 
  <tr> 
   <td>TypeError</td> 
   <td>对类型无效的操作</td> 
  </tr> 
  <tr> 
   <td>ValueError</td> 
   <td>传入无效的参数</td> 
  </tr> 
  <tr> 
   <td>UnicodeError</td> 
   <td>Unicode 相关的错误</td> 
  </tr> 
  <tr> 
   <td>UnicodeDecodeError</td> 
   <td>Unicode 解码时的错误</td> 
  </tr> 
  <tr> 
   <td>UnicodeEncodeError</td> 
   <td>Unicode 编码时错误</td> 
  </tr> 
  <tr> 
   <td>UnicodeTranslateError</td> 
   <td>Unicode 转换时错误</td> 
  </tr> 
  <tr> 
   <td>Warning</td> 
   <td>警告的基类</td> 
  </tr> 
  <tr> 
   <td>DeprecationWarning</td> 
   <td>关于被弃用的特征的警告</td> 
  </tr> 
  <tr> 
   <td>FutureWarning</td> 
   <td>关于构造将来语义会有改变的警告</td> 
  </tr> 
  <tr> 
   <td>OverflowWarning</td> 
   <td>旧的关于自动提升为长整型(long)的警告</td> 
  </tr> 
  <tr> 
   <td>PendingDeprecationWarning</td> 
   <td>关于特性将会被废弃的警告</td> 
  </tr> 
  <tr> 
   <td>RuntimeWarning</td> 
   <td>可疑的运行时行为(runtime behavior)的警告</td> 
  </tr> 
  <tr> 
   <td>SyntaxWarning</td> 
   <td>可疑的语法的警告</td> 
  </tr> 
  <tr> 
   <td>UserWarning</td> 
   <td>用户代码生成的警告</td> 
  </tr> 
 </tbody> 
</table>

### **异常处理** ###

捕捉异常可以使用try/except语句。try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。如果你不想在异常发生时结束你的程序，只需在try里捕获它。

**语法：**

try:
    <语句>        #运行别的代码
    except <名字>：
    <语句>        #如果在try部份引发了'name'异常
    except <名字>，<数据>:
    <语句>        #如果引发了'name'异常，获得附加的数据
    else:
    <语句>        #如果没有异常发生

**实例：**

#!/usr/bin/python
    # -*- coding: UTF-8 -*-
    
    try:
        fh = open("testfile", "w")
        fh.write("这是一个测试文件，用于测试异常!!")
    except IOError:
        print "Error: 没有找到文件或读取文件失败"
    else:
        print "内容写入文件成功"
        fh.close()

**运行：**

$ python test.py 
    内容写入文件成功
    $ cat testfile       # 查看写入的内容
    这是一个测试文件，用于测试异常!!

### 使用except而不带任何异常类型 ###

try-except语句捕获所有发生的异常。但这不是一个很好的方式，我们不能通过该程序识别出具体的异常信息。因为它捕获所有的异常

**语法：**

try:
        正常的操作
       ......................
    except:
        发生异常，执行这块代码
       ......................
    else:
        如果没有异常执行这块代码

### 使用except而带多种异常类型 ###

**语法：**

try:
        正常的操作
       ......................
    except(Exception1[, Exception2[,...ExceptionN]]]):
       发生以上多个异常中的一个，执行这块代码
       ......................
    else:
        如果没有异常执行这块代码

### try-finally 语句 ###

**语法：**

try:
    <语句>
    finally:
    <语句>    #退出try时总会执行
    raise

**实例：**

#!/usr/bin/python
    # -*- coding: UTF-8 -*-
    
    try:
        fh = open("testfile", "w")
        fh.write("这是一个测试文件，用于测试异常!!")
    finally:
        print "Error: 没有找到文件或读取文件失败"

**运行：**

$ python test.py 
    Error: 没有找到文件或读取文件失败

### 异常参数 ###

一个异常可以带上参数，可作为输出的异常信息参数。变量接收的异常值通常包含在异常的语句中。在元组的表单中变量可以接收一个或者多个值。元组通常包含错误字符串，错误数字，错误位置。

**语法：**

try:
        正常的操作
       ......................
    except ExceptionType, Argument:
        你可以在这输出 Argument 的值...

**实例：**

#!/usr/bin/python
    # -*- coding: UTF-8 -*-
    
    # 定义函数
    def temp_convert(var):
        try:
            return int(var)
        except ValueError, Argument:
            print "参数没有包含数字\n", Argument
    
    # 调用函数
    temp_convert("xyz");

**运行：**

$ python test.py 
    参数没有包含数字
    invalid literal for int() with base 10: 'xyz'

### 触发异常 ###

**语法：**

raise [Exception [, args [, traceback]]]

**实例：**

def functionName( level ):
        if level < 1:
            raise Exception("Invalid level!", level)
            # 触发异常后，后面的代码就不会再执行

### 自定义异常 ###

通过创建一个新的异常类，程序可以命名它们自己的异常。异常应该是典型的继承自Exception类，通过直接或间接的方式。

**语法：**

class Networkerror(RuntimeError):
        def __init__(self, arg):
            self.args = arg

**触发上面异常：**

try:
        raise Networkerror("Bad hostname")
    except Networkerror,e:
        print e.args

下一篇：[7天入门Python 6 — 输入输出、文件及OS][7_Python 6 _ _OS]

> 感兴趣的同学可以点关注哦,持续更新~

[7_Python 1 _ Python]: https://blog.csdn.net/chenxuegui1234/article/details/17981203
[7_Python 2 _ Python]: https://blog.csdn.net/chenxuegui1234/article/details/102160203
[7_Python 3 _ Python]: https://blog.csdn.net/chenxuegui1234/article/details/102228385
[7_Python 4 _]: https://blog.csdn.net/chenxuegui1234/article/details/102654410
[7_Python 5 _]: https://blog.csdn.net/chenxuegui1234/article/details/102655478
[7_Python 6 _ _OS]: https://blog.csdn.net/chenxuegui1234/article/details/102770678
[https_docs.python.org_zh-cn_3.6_library_functions.html]: https://docs.python.org/zh-cn/3.6/library/functions.html