Python►Python Learn►python 过程编程

python 过程编程

python 过程编程

python流程控制(判断和循环)使用结构化的方法来封装程序
python过程编程主要使用’函数’和’模块’的方法来封装程序

1.函数定义和声明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
1. 函数是什么?
函数是一种语法结构(它把一些指令封装在一起,形成一个组合)
函数是对封装的完美解释(输入的数据被称为参数,参数影响函数的行为)
综上,函数的方式包含:
* 集合的对应关系
* 数据的魔法盒子
* 语句的封装

2. 定义函数
def square_sum(a,b):
    a = a**2
    b = b**2
    c = a + b
    return c
    print("am I alive?")

python使用def定义函数,square_sum是函数名字,括号中的a和b表示传入函数的参数,冒号后面五行都有缩进表示这五行代码都是函数体.
当函数被调用时,python将依次执行函数体,return用于返回函数结果,同时函数体执行到return后就会结束,不管它后面是否有其它函数定义语句

3. 调用函数
使用函数的过程叫调用函数.调用函数常用的方法是把函数返回值赋予给变量

x = square_sum(3,4)
print(x)

3对应a,4对应b,square_sum(3,4)返回结果为25,返回值25赋予变量x,然后由print打印输出

4. 函数文档
def square_sum(a,b):
    """return the square sum of two arguments"""
    a = a**2
    b = b**2
    c = a + b
    return c
    print("am I alive?")

help(square_sum)

在函数体第一行增加了一个多行注释,这个多行注释同样有缩进,它将成为该函数的说明文档

2.参数的传递

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
1. 基本传参
把数据用参数的形式输入到函数,被称为参数传递.

//以位置形式来确认传入的参数
def print_arg(a,b,c):
    """print args"""
    print(a,b,c)

//以关键字形式来确认传入的参数
def print_arg(b=2,a=3,c=1):
    """print args"""
    print(a,b,c)

//混合使用
def print_arg(b,a=2,c=1):
    """print args"""
    print(a,b,c)

2. 包裹传参
包裹传参的意思是传递任意个参数(参数不明确)

//包裹传参,以位置形式来传入参数,返回结果为元组
def print_arg(*args):
   """print args"""
   print(args)

//包裹传参,以关键字形式来传入参数,返回结果为字典
def print_arg(**args):
    """print args"""
    print(args)

//包裹传参,混合使用
def print_arg(*arg,**args):
    """print args"""
    print(arg)
    print(args)

综上,包裹传参和基本参数混合使用,它们的先后顺序为: 位置 -> 关键字 -> 包裹位置 -> 包裹关键字

[root@smallasa ~]# cat test.py
#!/usr/bin/env python
# -*- coding:utf-8 -*-

def print_arg(a,b,*c,**d):
    """print args"""
    print(a,b,c,d)

print_arg(1,2,3,4,e=1,f=2)
[root@smallasa ~]# python test.py
(1, 2, (3, 4), {'e': 1, 'f': 2})

3. 解包裹
包裹传递使用'*'和'**'用于函数定义,同时'*'和'**'还可以用于函数调用
注意: 包裹传参和解包裹不是相反操作,而是两个相对独立的功能

//解包裹,以位置形式传递,返回的是元组
def print_arg(a,b,c):
    "print args"
    print(a,b,c)
args = (1,2,3)
print_arg(*args)

//解包裹,以关键字形式传递,返回的是元组
def print_arg(a,b,c):
    "print args"
    print(a,b,c)
args = {"a":1,"b":2,"c":3}
print_arg(**args)

综上,解包裹用于函数调用,它们的先后顺序为: 位置 -> 关键字 -> 解包裹位置 -> 解包裹关键字

3.递归

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1. 递归是什么
递归是函数调用其自身的操作.为了防止计算机陷入死循环,递归要求程序有一个能够达到的终止条件
递归源自数学归纳法.数学归纳法是一种书序证明方法,常用于证明命题在自然数范围之内成立

2. 函数栈
程序中的递归用到栈,栈是数据结构的一种,可以有序的存储数据
栈最显著的特征是: 后进先出
栈是由多个帧组成,栈只支持'pop'和'push'('pop'用于取出栈顶元素;'push'用于推入栈顶元素)
所以,程序运行中,可以看做是一个先增长栈后消灭栈的过程

3. 变量作用域
* 函数内部可以创建新的变量
* 函数内部可以看到函数外部已经存在的变量
* 函数内部对A变量操作,不会影响到函数外部变量A
* 函数的参数与函数的内部变量类似,我们可以把参数理解为函数内部的变量

4.模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
1. 引入模块
在python中,一个".py"文件就是一个模块.通过模块,你可以调用其文件中的函数
引起模块(import),就是为了在新的程序中重复使用已有的python程序
模块是比函数更高一层的封装.把常见的功能编写到模块,方便未来使用,这些模块就是所谓的库

引入模块方法: import 和 from ... import ...

2. 搜索路径
在引入模块时,如果库文件和应用文件在同一目录下,python会自动在当前文件夹搜索;如果在当前文件夹下搜索不到,会到标准库的安装路径和操作系统环境变量PYTHONPATH指定的路径下寻找

//查看当前模块路径
>>> import sys
>>> print(sys.path)

//添加模块路径
export PYTHONPATH=/path/to/pylib:$PYTHONPATH

5.异常处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
1. 异常种类
* 只有在代码执行时才出现的错误称为运行时错误
* 语义错误,也是最难排查的错误

2. 异常处理
异常处理可以提高程序的容错性

异常处理格式:
try:
    ...
except excepation1:
    ...
except excepation2:
    ...
else:
    ...
finally:
    ...

try:
    ...
except Exception as e:
    print e


使用raise关键字,我们在程序中主动抛出异常
def functionName( level ):
    if level < 1:
        raise Exception("Invalid level!", level)