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 语句块的执行顺序为：如果条件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 循环的作用是：遍历序列（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，举例：

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 add(x1, x2):
    z = x1 + x2
    return z

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

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

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

<map at 0x7fda51470340>

可以用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 内置了一些常用的函数，可以方便使用。本书简单介绍以下几个内置函数：

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 函数可以对可迭代对象进行排序，默认为升序，可迭代对象一般是列表。文章来源地址https://www.toymoban.com/news/detail-689386.html

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

[12, 23, 37, 54]

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

[54, 37, 23, 12]

到了这里，关于Python 编写函数的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！