Python 编写函数

条件语句

编写程序时，经常用到一些条件或判断，需要用到 if 语句，它的字面意思是：如果（if）满足条件，做什么，否则（else）做什么。例如，下面一段代码：

a = 10
if a > 10:
    print("Value of a is greater than 10")
else:
    print("Value of a is not greater than 10")

Value of a is not greater than 10

这段代码的意思是，如果 a 比 10 大，则输出 “Value of a is greater than 10”，否则输出 “Value of a is not greater than 10”。if 语句还可以跟 elif （else if 的意思），再次判断一个条件。

if 语句的一般用法
if 条件1:
statement_block_1
elif 条件2:
statement_block_2
else:
statement_block_3

上面 if 语句块的执行顺序为：如果条件1 为真，将执行 “statement_block_1” 块语句，如果条件1 为假，将判断 “条件2”，如果条件2 为真，将执行 “statement_block_2” 块语句，如果条件2 为假，将执行"statement_block_3"块语句。举例：

wage = int(input("请输入你的月薪: "))
print("")
if wage <= 3000:
    print("贫困户")
elif wage <= 12000:
    print("平均水平")
else:
    print("土豪")

请输入你的月薪: 4000

平均水平

上面语句的意思是，若输入的月薪小于 3000，则输出“贫困户”，否则若月薪在 3000 与 12000 之间，输出“平均水平”，若月薪在 12000 之上，则输出“土豪”。if 语句里面还可以嵌套 if 语句，进一步增加判断条件，举例：

wage = int(input("请输入你的月薪: "))
print("")
if wage <= 3000:
    print("贫困户")
    if 2000 <= wage < 3000:
        print("贫困户中的一般贫")
    if wage <= 1000:
        print("贫困户中的特贫")
else:
    print("不是贫困户")

请输入你的月薪: 3000

贫困户

在上面的程序中，若月薪小于等于 3000，又嵌套了两个条件进一步判断。

if 中条件判断中常用的符号有：>(大于), <(小于), >=(大于等于), <=(小于等于), ==(等于), !=(不等于)。需要注意的是，在编程语言的判断语句中，两个等号 == 表示判断是否相等（a == 3 表示判断 a 是否等于 3），而一个等号 = 表示的是变量赋值（a = 3 表示将 a 赋值为 3）

循环语句

循环语句一般有两种，for 语句与 while 语句。for 循环可以遍历任何序列的项目，如一个列表、元组、集合或者一个字符串。for 循环的一般用法如下：

for 循环语句的一般用法
for variable in sequence:
statements

for 循环的作用是：遍历序列（sequence）中的所有元素，执行命令语句 statements，举例：

for i in range(3):
    print(i)

0
1
2

输出结果为 0， 1， 2，上述代码的作用是，对于 range(3) 中的每一个元素，打印元素。for 循环经常结合序列函数 range() 一起使用：range(a) 表示从 0 到 a-1 的一个数列，range(a, b) 表示从 a 到 b-1 的一个数列，range(a, b, c) 表示从 a 到 b-1，步长为 c 的一个数列。

另一个 while 循环语句的一般格式为：

while 循环语句的一般用法
while  判断条件:
statements

它的作用是，只要满足 while 的判断条件，则一直执行 while 下面的执行语句 statements，举例：

a = 1
while a < 4:
    print(a)
    a = a + 1

1
2
3

上面语句的作用是：只要 a 小于 4，则将 a 值打印出来并将 a 值加 1，在 a 等于 4 时停止执行 while语句。

for 循环与 while 循环经常结合break或continue语句，break语句可以跳出循环体，而continue语句用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。举例：

for i in range(3):
   if i == 1:
       break
   print(i)
print('循环结束')

0
循环结束

上面代码中，在 i 等于 1 时执行break跳出了整个循环体。

若改为continue语句：

for i in range(3):
   if i == 1:
       continue
   print(i)
print('循环结束')

0
2
循环结束

上面代码中，在 i 等于 1 时执行continue跳出了当前循环，执行剩下的循环。

在 while 循环中，break与continue的例子：

a = 1
while a < 5:
    a = a + 1
    if a == 3:
        break 
    print(a)
print('循环结束')

2
循环结束

a = 1
while a < 5:
    a = a + 1
    if a == 3:
        continue 
    print(a)
print('循环结束')

2
4
5
循环结束

自定义函数

Python 提供了许多内建函数，比如 print()，但也可以自己创建函数，这被叫做用户自定义函数。掌握了自定义函数后，就能用 Python 实现很多自己想要的功能了。Python 自定义函数使用def关键字，一般用法如下：

def 自定义函数的一般用法
def 函数名(参数列表):
statements

下面的几行代码定义了一个加和函数：

def add(x1, x2):
    z = x1 + x2
    return z

该自定义函数有以下几个特点：

def	关键字 def 开头
add	函数的名字，可以自命名
(x1, x2)	小括号里面是函数的输入参数
:	冒号，换行写函数内容；若不换行，整个函数只能有一行代码
return	关键字，后面跟函数的返回值，即输出结果

函数的返回值可以有一个或多个，下面的代码返回多个值，既返回两个参数的加和结果，又返回两个参数的值。

def add(x1, x2):
    z = x1 + x2
    return z, x1, x2

调用函数时，通过输入函数名字，并把函数的参数传递进去，例如：

def add(x1, x2):
    z = x1+x2
    return z

x1 = 10
x2 = 6
print(add(x1, x2))

16

在多个返回值时，有时候需要用新的变量表示各个返回值，可以用下面的方式赋值：

def add(x1, x2):
    z = x1+x2
    return z, x1, x2

x1 = 10
x2 = 6
sums, a, b = add(x1, x2) # 用新变量赋值
print(sums)
print(a)
print(b)

16
10
6

若某个返回值不使用，可以用下划线_替代该变量名。

def add(x1, x2):
    z = x1+x2
    return z, x1, x2

x1 = 10
x2 = 6
sums, _, b = add(x1, x2) # 用下划线 _ 替代第二个返回值
print(sums)
print(b)

16
6

上面的代码中，用下划线替代第二个返回参数值，用新的变量名替代其他参数值。

函数也可以不带输入参数，即小括号里面可以没有内容，例如，下面的代码打印一句话 ``Hello, world!"：

def hello():
    print('Hello, world!')

hello()

Hello, world!

函数参数的传递类型

根据输入参数的值是否可以改变，函数的参数传递类型包括以下两种：

• 不可变类型：数字，字符串，元组
• 可变类型：列表，字典，集合

对于不可变类型，函数调用参数后，参数原来的值不变，例如：

def changeNum(a):
    a = 10

b = 2
changeNum(b)
print(b)    # 结果还是 2

2

上面的代码中，由于传递的是数字类型，调用函数后，参数原来的数值不变，对于字符串或元组类型，传递时也是这样。

对于可变类型，函数调用参数后，参数原来的值也改变，例如：

def changeList(mylist):
  mylist.extend([1, 2, 3])
  return mylist

listTry = [10, 20, 30]
changeList(listTry)
print(listTry)  # 结果是 [10, 20, 30, 1, 2, 3]，改变了列表原来的值

[10, 20, 30, 1, 2, 3]

函数的参数传入方法

函数的参数传入方法主要有4种类型：

• 顺序传入
• 赋值传入
• 默认参数值传入
• 不定长参数传入

对于顺序传入，函数的参数值跟输入的顺序一一对应：

def minus(x1, x2):
    z = x1 - x2
    return z

print(minus(10, 6))

4

在上面的代码中，调用 minus 函数，按照参数的顺序，认为 x1 的值为 10， x2 的值为 6。

赋值传入的意思是：在调用函数时，可以在输入参数时直接给参数赋值，Python 自动根据括号内的参数名匹配参数值，例如：

def minus(x1, x2):
    z = x1 - x2
    return z

print(minus(x2 = 10, x1 = 6))

-4

在上面的代码中，调用 minus 函数时，在小括号内对参数进行了赋值，认为 x2 的值为 10， x1 的值为 6。

Python 在定义函数时，可以设置参数的默认值，当调用参数时，若没有给参数赋值，则使用参数的默认值，例如：

def minus(x1, x2 = 6):
    z = x1 - x2
    return z

print(minus(x1 = 10))  # 输出：4，没有传递参数值时默认参数值
print(minus(x1 = 10, x2 = 5))  # 输出：5，有传递参数值时，覆盖默认参数值

4
5

当一个函数传递多个参数，但不太确定究竟是多少个时，可以用 *args 表示多个参数，例如：

def plus(x, *args):
    print('x is %d' % x)
    for var in args:
        x += var
    print('final x is %d' % x)

plus(3, 4, 5) # *args 是 4, 5
plus(3, 4, 5, 6) # *args 是 4, 5, 6

x is 3
final x is 12
x is 3
final x is 18

可以用 **args 来传递不定长的多个赋值的参数，例如：

def minus(x1, **args):
    sum = 0
    for key in args:
        sum += args[key]
        return x1 - sum

print(minus(10, x2 = 3, x3 = 5))

7

上面的代码中，用 **args 表示 x2 = 3, x3 = 5。

lambda, map, filter, reduce 函数

Python 使用lambda来创建匿名函数。所谓匿名，即不再使用 def 语句这样标准的形式定义一个函数。lambda 函数只有一行，用一个冒号分割传递参数与函数的返回值。非常简洁，在 Pandas 处理数据时经常结合 apply 函数使用。

add = lambda x1, x2: x1 + x2
print(add(10, 6)) 

16

也可以结合 if-else 语句定义 lambda 函数。

Max = lambda a, b: a if(a > b) else b
print(Max(12, 20))

20

map(fun, iter) 对每一个可迭代对象 iter 中的元素应用 fun 函数，并返回一个 map 类型的可迭代对象。fun 函数既可以使用 lambda 匿名函数，也可以用 def 自定义一个函数。

a = [1, 2, 3]
b = map(lambda x: x**2, a) # 对 a 中每个元素平方
b

可以用list()函数将这个可迭代对象转化为 list 类型：

list(b)

[1, 4, 9]

``filter(fun, iter)`` 对可迭代对象 iter 中的每一个元素应用判断函数 fun 过滤，并返回一个 filter 类型的可迭代对象。

a = [1, 2, 3]
b = filter(lambda x: x >= 2, a) # 将大于等于 2 的元素过滤出来
list(b)

[2, 3]

reduce(fun, iter)首先对可迭代对象 iter 中的前两个元素应用函数 fun，然后将其结果作为 fun 的第一个输入值，再对第 3 个元素应用 fun 函数；以此类推，最后返回一个数。使用 reduce 函数需要从工具包 functools 中提前导入。

from functools import reduce # 从工具包 functools 中导入 reduce

a = [1, 2, 3, 4]
b = reduce(lambda x1, x2: x1 + x2, a) # 求和
b

10

reduce也可以跟 3 个参数，即reduce(fun, iter, start=None)。此时，首先对一个初始值 start 与可迭代对象 iter 中的第一个元素应用函数 fun，然后将其结果作为 fun 的第一个输入值，再对第 2 个元素应用 fun 函数；以此类推，最后返回一个数。

a = [1, 2, 3, 4]
b = reduce(lambda x1, x2: x1 + x2, a, 10) # 求和，起始值为 10
b

20

try-except 语句调试

在编写程序时，有时候不知道程序能否正确运行，想试试程序运行结果如何，可以使用 try-except语句；若 try 块中的语句无法执行通过，则执行 except 块中的语句。

这个语句在程序调试时经常使用，下面的代码定义了一个除法函数：

def devide(x1, x2):
    try:
        z = x1/x2
        print(z)
    except:
        print('x2 should not be zero')

devide(5, 0)

x2 should not be zero

上面的代码中，若 x1 能除以 x2，则输出除法结果，否则提示 x2 不能为零。

Python 还有一个关键字pass，不执行任何命令。一般用做占位语句，在程序调试时可以使用。

def devide(x1, x2):
    try:
        z = x1/x2
        print(z)
    except:
        pass

devide(5, 0)

上面的代码中，若 x1 能除以 x2，则输出除法结果，否则程序不输出任何结果。

一些常用的内置函数

Python 内置了一些常用的函数，可以方便使用。本书简单介绍以下几个内置函数：

sum	对可迭代对象（如列表，元组，集合）求和
max	返回输入参数中的最大值
min	返回输入参数中的最小值
abs	返回输入数值的绝对值
round	返回输入数值的四舍五入值
range	创建一个整数序列类型，多用于 for 循环
enumerate	将一个可迭代的对象，同时列出各个数据和对应索引，常用在 for 循环中
sorted	对可迭代对象进行排序，默认升序

round(3.1415926, 2)  # 四舍五入时保留两位小数

3.14

round(3.1415926) # 默认四舍五入为整数

3

range 被 Python 直接视为一种数据类型，表示一个整数数列。包含终点（必有），起点（可选），步长（可选）。可以用list()将 range 类型转化为列表类型。

range(10)  # 创建一个从 0 到 10 (不包括 10) 的整数序列，默认起点为 0，默认步长值为 1

range(0, 10)

list(range(10))

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

range(2, 10)  # 创建一个从 2 到 10 的整数序列

range(2, 10, 2) # 创建一个从 2 到 10 的整数序列，并且步长值为 2

range(2, 10, 2)

list(range(2, 10, 2))

[2, 4, 6, 8]

eumerate 经常结合 for 循环使用。

a = [20, 30, 40, 50]
for i in range(len(a)):
    print(a[i], i)

20 0
30 1
40 2
50 3

使用 enumerate 则上述代码更简洁些：

a = [20, 30, 40, 50]
for item, i in enumerate(a):
    print(item, i)

0 20
1 30
2 40
3 50

sorted 函数可以对可迭代对象进行排序，默认为升序，可迭代对象一般是列表。

arr = [23, 54, 12, 37]
sorted(arr)  # 对列表升序排列

[12, 23, 37, 54]

sorted(arr, reverse = True)  # 对列表降序排列

[54, 37, 23, 12]