每天 3 分钟，小闫带你学 Python(二十三)

每日分享

Don't let small minds convince you that your dreams are too big.

别让狭小的思维限制了你做伟大的梦。

小闫语录：

不要禁锢自己的想法，连想都不敢想，如何实现？

前言

昨天的文章『每天 3 分钟，小闫带你学 Python(二十二)』讲解了很多概念：

1.局部变量是定义在函数内部的变量，而且作用域也是本函数；全局变量是定义在函数外的变量，所有函数都可以进行访问。

2.全局变量通过在函数内部声明的方式修改。使用 global

3.Python 中的函数参数是传递引用。

4.可变数据类型有列表、字典和集合；不可变数据类型有数字、字符串和元组。

学习目标

1.了解递归函数。

2.熟练掌握匿名函数的使用。

3.熟记列表推导式、字典推导式、三目运算符的形式。

4.熟练使用三个常用工厂函数。

1.递归函数（了解即可）

通过前面学习已经知道函数内部可以调用其他函数。那你有没有想过函数内部调用函数本身？哈哈哈，如果一个函数内部不调用其他的函数，而是调用函数自身，这个函数就是递归函数。说起来很简单，你也想问它有什么用呢？下面举例说明递归函数的作用：

需求：计算阶乘 n!=1*2*3*...*n

一个数字的阶乘就是从1连续乘到该正整数。用符号 n! 表示。

我们可以先来看一下阶乘的规律：

1! = 1
2! = 2 × 1 = 2 × 1!
3! = 3 × 2 × 1 = 3 × 2!
4! = 4 × 3 × 2 × 1 = 4 × 3!
...
n! = n × (n-1)!

1.1 解法一：循环

其实并不难解决，通过规律，我们可以通过如下代码解出：

def calNum(num):
    i = 1
    result = 1
    while i <= num:
        result *= i
        i += 1
    return result

1.2 解法二：递归

递归操作起来就贼简单了：

def factorial(num):
    if num > 1:
        result = num * factorial(num-1)
    else:
        result = 1
    return result

递归就是不断的调用自己，因此必须设置递归退出条件，否则会一直调用直至电脑卡死。

我们使用图片分析一下上述递归执行过程：

2. 匿名函数

匿名函数即没有名字的函数，省略了 def 声明函数的标准步骤，采用极简的语法实现一个函数。

匿名函数使用关键字 lambda 创建，语法为：

1. lambda[arg1 [,arg2,.....argn]]:expression
   

arg 代表参数， : 右方填写相关操作的表达式。

举例说明，要求写一个函数可以求两个数字的和，使用匿名函数：

1. lambda num1, num2: num1 + num2
   

一行代码就可以搞定，但是问题来了，该如何调用此函数呢？看下方：

sum = lambda num1, num2: num1 + num2
# 调用sum函数
print("Value of total : %d " % sum( 10, 20 ))
print("Value of total : %d " % sum( 20, 20 ))

相当于给函数临时起了一个名字，使用此名字即可调用匿名函数。

输出结果为：

1. Value of total :30
   
2. Value of total :40
   

注意：Lambda 函数可以接收任何数量的参数，但是只能返回一个表达式的值，因此只能使用其进行简单操作。匿名函数是不能直接调用 print 函数的，因为匿名函数需要一个表达式，相当于默认使用了 return。

2.1 小案例

有如下的一个列表，需要分别根据年龄和姓名进行排序：

stus = [
    {"name": "EthanYan", "age": 18}, 
    {"name": "xiaohong", "age": 19}, 
    {"name": "wangyingxuan", "age": 17}
]

排序操作可以使用列表的 sort 方法。

按name排序：

>>> stus.sort(key = lambda x: x['name'])
>>> stus
[{'name': 'EthanYan', 'age': 18}, {'name': 'wangyingxuan', 'age': 17}, {'name': 'xiaohong', 'age': 19}]

按age排序：

>>> stus.sort(key = lambda x: x['age'])
>>> stus
[{'name': 'wangyingxuan', 'age': 17}, {'name': 'EthanYan', 'age': 18}, {'name': 'xiaohong', 'age': 19}]

3.列表推导式

所谓的列表推导式，就是指快速的使用循环操作创建列表，只需一行代码即可。

创建列表 [0,1,2,3,4,5]，传统的方式如何：

list = []
for i in range(6):
    list.append(i)

使用列表推导式如何：

1. list =[i for i in range(6)]
   

大家可以对比总结规律，如果没看出来怎么写的，那么再看一个例子：

创建列表 [0,2,4]，传统方式如下：

list = []
for i in range(6):
    if i % 2 == 0:
        list.append(i)

使用列表推导式如何：

1. list =[i for i in range(6)if i%2==0]
   

列表推导式其实就是简化了原先的程序，为了快速创建列表。在列表（中括号中）中第一个位置填写要添加到列表中的元素值（满足后面条件的元素），然后书写空格，再填写循环语句，如果有复杂操作（如 if 语句和多层 for 循环）的话，条件依次往后填写，条件之间使用空格隔开。

可以多举几个例子，仿照示例实现。

4.字典推导式

字典推导式与列表推导式类似，语法格式如下：

1. my_dict ={ expr for value in collection if condition }
   

expr 代表的是相关操作，如相加减等。

collection 代表可迭代对象。

value 代表 collection 中的元素。

condition 代表条件判断语句。

注意外侧是大括号（花括号）

示例：将两个列表转换成一个字典

keys = ['a', 'b', 'c', 'd']
vals = [10, 20, 30, 40]
my_dict = {key: value for key, value in zip(keys, vals)}
print(my_dict)
# 结果为 {'a': 10, 'b': 20, 'c': 30, 'd': 40}

扩展：zip 函数可以将多个列表、元组等可迭代对象进行压缩操作，即将对应下标的元素打包成一个个元组，然后返回一个由这些元组组成的 zip 对象，可以使用 list() 方法将其转化为可见的列表。压缩完之后取值可以使用循环，也可以使用前面讲到的拆包，还可以使用解压缩操作。

如果输入的可迭代对象元素个数不一致，按元素个数最少的为准，返回最少元素个数的元组组成的对象。

实例：

>>> a = [1, 2, 3]
>>> b = [3, 2, 1]
>>> c = [4, 5, 6, 7, 8]
# 进行压缩操作
>>> zipped = zip(a, b)
# 返回一个zip对象
>>> zipped
<zip object at 0x000001DD466C9F88>
# 使用 list() 方法将其转化为可见的列表
>>> list(zipped)
[(1, 3), (2, 2), (3, 1)]
# 压缩的可迭代对象元素个数不一致时，以最短的为准
>>> list(zip(a,c))
[(1, 4), (2, 5), (3, 6)]
# zip(*) 为解压缩
>>> num1, num2 = zip(*zip(a,b))
>>> list(num1)
[1, 2, 3]
>>> list(num2)
[3, 2, 1]

5.三目运算符

先不要纠结这个名字，我们通过示例来了解它到底是个什么鬼。它与列表推导式、字典推导式等一样都是为了简化代码。

需求：通过用户输入的年龄，判断用户是否能进入网吧。

传统方式：

def function():
    age = int(input("请输入您的年龄："))
    if age > 18:
        return "您可以进入网吧"
    else:
        return "滚回去写作业"
msg = function()
print(msg)
# 输出结果
请输入您的年龄：20
您可以进入网吧

使用三目运算符：

def function():
    age = int(input("请输入您的年龄："))
    return "您可以进入网吧" if age>18 else "滚回去写作业"
msg = function()
print(msg)

三目运算符语法格式：

1. 条件成立结果if条件else条件不成立结果
   

6.三个常用工厂函数

三个常用的工厂函数为 list、 set、 tuple

set 是集合；list 为列表；tuple 为元组

使用方式：直接对操作对象转换即可，如

1. list(操作对象)
   

1.三者之间可以随意转换：

# 首先定义一个列表
>>> mylist = [1, 2, 3]
# 使用tuple将列表转换为元组
>>> tuple(mylist)
(1, 2, 3)
# 使用set将列表转换为集合
>>> set(mylist)
{1, 2, 3}
>>> list(mylist)
[1, 2, 3]

2. set() 方法常用来去重操作。

>>> mylist = [1, 2, 3, 5, 3, 2, 3, 6]
>>> newmylist = set(mylist)
>>> newmylist
{1, 2, 3, 5, 6}

作业

1.请写出一段 Python 代码实现分组一个 list 里面的元素，比如 [1,2,3,...100] 变成 [[1,2,3],[4,5,6]....]

使用列表推导式实现

参考答案：

1. a =[x for x in range(1,101)]
   
2. b =[a[x:x+3]for x in range(0,len(a),3)]
   

2.使用递归函数输出斐波那契数列。

3.动手实现本文章内所有代码示例。