Python入门——函数，面向过程的编程

第一部分 函数的定义及调用

1.1 为什么要用函数

1. 提高代码复用性——抽象出来，封装为函数
2. 将复杂的大问题分解成一系列小问题，分而治之——模块化设计的思想
3. 利于代码的维护和管理

1.2 函数的定义及调用

• 定义

def  函数名（参数）：
    函数体
    return 返回值

• 调用

函数名（参数）

• 举例：求正方形的面积

def area_of_square(length_of_side):
    square_area = pow(length_of_side, 2)
    return square_area    


area = area_of_square(5)
print(area)

25

1.3 参数传递

1.3.1 形参与实参

• 形参（形式参数）：函数定义时的参数，实际上就是变量名
• 实参（实际参数）：函数调用时的参数，实际上就是变量的值

1.3.2 位置参数（关联）

• 严格按照位置顺序，用实参对形参进行赋值
• 一般用在参数比较少的时候

def function(x, y, z):
    print(x, y, z)
    
    
function(1, 2, 3)

1 2 3

注意： 实参与形参个数必须一一对应，一个不能多，一个不能少。

1.3.3 关键字参数（形参=实参）

• 打破位置限制，直呼其名的进行值的传递
• 必须遵守实参与形参数量上一一对应
• 多用在参数比较多的场合

def function(x, y, z):
    print(x, y, z)
    
    
function(y=1, z=2, x=3)

3 1 2

位置参数可以与关键字参数混合使用，但是，位置参数必须放在关键字参数前面

def function(x, y, z):
    print(x, y, z)
    
    
function(1, z=2, y=3)

1 3 2

注意： 不能为同一个形参重复传值

def function(x, y, z):
    print(x, y, z)
​
​
function(1, z=2, x=3)    # 会报错

1.3.4 默认参数

• 在定义阶段就给形参赋值——该形参的常用值
• 默认参数必须放在非默认参数后面
• 调用函数时，可以不对该形参传值
• 机器学习库中类的方法里非常常见

def register(name, age, sex="male"):
    print(name, age, sex)
​
​
register("大杰仔", 18)
register("林志玲", 38, "female")

大杰仔 18 male
林志玲 38 female

注意： 默认参数应该设置为不可变类型（数字、字符串、元组）

def function(ls=[]):
    print(id(ls))
    ls.append(1)
    print(id(ls))
    print(ls)


function()
function()

1959175661640
1959175661640
[1]
1959175661640
1959175661640
[1, 1]

def function(ls="Python"):
    print(id(ls))
    ls += "3.7"
    print(id(ls))
    print(ls)
    
    
function()
function()

1959105366128
1959176424048
Python3.7
1959105366128
1959176424240
Python3.7

让参数变成可选的

def name(first_name, last_name, middle_name=None):
    if middle_name:
        return first_name+middle_name+last_name
    else:
        return first_name+last_name
    
    
print(name("大","仔"))
print(name("大", "仔", "杰"))

大仔
大杰仔

1.3.5 可变长参数 *args

• 不知道会传过来多少参数
• 该形参必须放在参数列表的最后

def foo(x, y, z, *args):
    print(x, y ,z)
    print(args)
    
    
foo(1, 2, 3, 4, 5, 6)    # 多余的参数，打包传递给args

1 2 3
(4, 5, 6)

实参打散

def foo(x, y, z, *args):
    print(x, y ,z)
    print(args)
​
    
foo(1, 2, 3, [4, 5, 6])    
foo(1, 2, 3, *[4, 5, 6])   # 打散的是列表、字符串、元组或集合

1 2 3
([4, 5, 6],)
1 2 3
(4, 5, 6)

1.3.6 可变长参数 **kwargs

def foo(x, y, z, **kwargs):
    print(x, y ,z)
    print(kwargs)
    
    
foo(1, 2, 3, a=4, b=5, c=6)    #  多余的参数，以字典的形式打包传递给kwargs

1 2 3
{'a': 4, 'b': 5, 'c': 6}

字典实参打散

def foo(x, y, z, **kwargs):
    print(x, y ,z)
    print(kwargs)
​
    
foo(1, 2, 3, **{"a": 4, "b": 5, "c":6})

1 2 3
{'a': 4, 'b': 5, 'c': 6}

可变长参数的组合使用

def foo(*args, **kwargs):
    print(args)
    print(kwargs)
    
  
foo(1, 2, 3, a=4, b=5, c=6) 


def func(x, *y, **z):
    print(x)
    print(y)
    print(z)  


ls = ["a", "b", "c"]
d = {"name": "Sarah", "age":18}
func(*ls, "d", **d)

(1, 2, 3)
{'a': 4, 'b': 5, 'c': 6}
a
('b', 'c', 'd')
{'name': 'Sarah', 'age': 18}

1.4 函数体与变量作用域

• 函数体就是一段只在函数被调用时，才会执行的代码，代码构成与其他代码并无不同
• 局部变量——仅在函数体内定义和发挥作用

def multipy(x, y):
    z = x*y
    return z   
​
​
multipy(2, 9)
print(z)            # 报错，因为函数执行完毕，局部变量z已经被释放掉了

• 全局变量——外部定义的都是全局变量
• 全局变量可以在函数体内直接被使用

n = 3
ls = [0]
def multipy(x, y):
    z = n*x*y
    ls.append(z)
    return z   
​
​
print(multipy(2, 9))
print(ls)

54
[0, 54]

通过 global 在函数体内定义全局变量

def multipy(x, y):
    global z
    z = x*y
    return z 
​
​
print(multipy(2, 9))
print(z)

18
18

1.5 返回值

1.5.1 单个返回值

def foo(x):
    return x**2
​
​
res = foo(10)
print(res)

100

1.5.2 多个返回值——以元组的形式

def foo(x):
    return 1, x, x**2, x**3    # 逗号分开，打包返回
​
​
print(foo(3))
a, b , c, d = foo(3)       # 解包赋值
print(a)
print(b)
print(c)
print(d)

(1, 3, 9, 27)
1
3
9
27

1.5.3 可以有多个 return 语句，一旦其中一个执行，代表了函数运行的结束

def is_holiday(day):
    if day in ["Sunday", "Saturday"]:
        return "Is holiday"
    else:
        return "Not holiday"
    print("啦啦啦德玛西亚，啦啦啦啦")       # 你丫根本没机会运行。。。
    
    
print(is_holiday("Sunday"))
print(is_holiday("Monday"))

Is holiday
Not holiday

1.5.4 没有return语句，返回值为None

def foo():
    print("我是孙悟空")
​
res = foo()
print(res)

我是孙悟空
None

1.6 几点建议

1.6.1 函数及其参数的命名参照变量的命名

• 字母小写及下划线组合
• 有实际意义

1.6.2 应包含简要阐述函数功能的注释，注释紧跟函数定义后面

def foo():
    # 这个函数的作用是为了给大家瞅一瞅，你瞅啥，瞅你咋地。。。。
    pass

1.6.3 函数定义前后各空两行

def f1():
    pass
​
                 # 空出两行，以示清白
def f2():
    pass
​
​​
# ...

1.6.4 默认参数赋值等号两侧不需加空格

def f3(x=3):    # 默认参数赋值等号两侧不需加空格
    pass

1.6.5 写好的函数要进行单元测试

assert——断言

• 表达式结果为 false 的时候触发异常

def fun(num):
    return num == 0


assert fun(2) == False
assert fun(2) == True

AssertionError                            Traceback (most recent call last)
<ipython-input-3-6a3ddfc225d1> in <module>
      4 
      5 assert fun(2) == False
----> 6 assert fun(2) == True

AssertionError: 

第二部分 匿名函数

2.1 基本形式—— lambda 变量: 函数体

• 冒号前面是输入
• 冒号后面是输出

sum = lambda arg1, arg2: arg1 + arg2
print("相加后的值为 : ", sum( 10, 20 ))

相加后的值为 :  30

2.2 常用用法

在参数列表中最适合使用匿名函数，尤其是与key = 搭配

排序sort() sorted()

ls = [(93, 88), (79, 100), (86, 71), (85, 85), (76, 94)]

ls.sort()    # 按照第1个值排序
print(ls)

ls.sort(key = lambda x: x[1])    # 按照第2个值排序
print(ls)

temp = sorted(ls, key = lambda x: x[0]+x[1], reverse=True)    # 按照和值降序排序
print(temp)

n = max(ls, key = lambda x: x[1])    # 第2个值最大的元素
print(n)

s = "八百标兵奔北坡，北坡八百炮兵炮。标兵怕碰炮兵炮，炮兵怕把标兵碰。"
d = {}
for i in s:
    d[i] = d.get(i, 0) + 1
print(dict(sorted(d.items(), key = lambda x : x[1], reverse=True)))

[(76, 94), (79, 100), (85, 85), (86, 71), (93, 88)]
[(86, 71), (85, 85), (93, 88), (76, 94), (79, 100)]
[(93, 88), (79, 100), (85, 85), (76, 94), (86, 71)]
(79, 100)
{'兵': 6, '炮': 5, '标': 3, '八': 2, '百': 2, '北': 2, '坡': 2, '，': 2, '。': 2, '怕': 2, '碰': 2, '奔': 1, '把': 1}