Python递归和推导

纸上得来终觉浅，绝知此事要躬行。

递归的概念很简单，如果函数包含了对其自身的调用，该函数就是递归的。拗口一点的定义是，如果一个新的调用能在相同过程中较早的调用结束之前开始，那么个该过程就是递归。

1. 条件运算符

• 三目运算符

# 表达格式
<表达式1> ? <表达式2> : <表达式3>

# 实例说明
In [1]: a = 1

In [2]: b = 2

In [3]: max = (a > b) ? a : b

• if 和 else

# 表达格式
value_when_true if condition else value_when_false

# 实例说明
In [4]: 'True' if True else 'False'
Out[4]: 'True'

In [5]: 'True' if False else 'False'
Out[5]: 'False'

• 老式写法：不推荐使用

# 表达格式
[value_when_false, value_when_true](bool(condition))

# 实例说明
In [6]: ['False', 'True'][True]
Out[6]: 'True'

In [7]: ['False', 'True'][False]
Out[7]: 'False'

• and 和 or

# 表达格式
condition and value_when_true or value_when_false

# 同为真返回最后一个真值，有假返回假值
In [11]: 'a' and 'b'
Out[11]: 'b'

In [12]: 'a' and False
Out[12]: False

In [13]: False and 'b'
Out[13]: False

In [14]: 'a' and False and 'b'
Out[14]: False

In [15]: 'a' and True and 'b'
Out[15]: 'b'

# 返回第一个真值
In [16]: 'a' or 'b'
Out[16]: 'a'

In [17]: 'a' or False
Out[17]: 'a'

In [18]: False or 'b'
Out[18]: 'b'

In [19]: 'a' or False or 'b'
Out[19]: 'a'

In [20]: 'a' or True or 'b'
Out[20]: 'a'

2. 递归运算

• 递归的定义
  • 在每一次调用自己时，在某种意义上应该更接近于解
  • 必定存在可使递归调用终止的条件, 否则导致出现无限递归

In [1]: def fac(n):
   ...:     if n == 1:
   ...:         return 1
   ...:     else:
   ...:         return n * fac(n-1)
   ...:

In [2]: def fac(n):
   ...:     return 1 if n == 1 else n * fac(n-1)
   ...:

• 递归的次数
  • 在计算机中，函数调用时通过栈的这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，这个栈就会减一层栈帧。由于栈的大小不是无限的，所以递归调用是有限制的。
  • 在Python2中递归的次数为1000，而在Python3中递归的次数为3000次，这个数值可以通过修改getrecursionlimit的数值来自由调控。

In [3]: import sys

In [4]: sys.getrecursionlimit()
Out[4]: 3000

In [5]: sys.getrecursionlimit(1000)

3. 解析和推导

解析式也成推导式，包含列表解析、集合解析和字典解析。

• 列表解析

In [1]: [i * i for i in [1, 2, 3, 4]]
Out[1]: [1, 4, 9, 16]

In [2]: [i * i for i in [1, 2, 3, 4] if i % 2]
Out[2]: [1, 9]

In [3]: [i * i for i in range(10) if i % 2 and i % 3]
Out[3]: [1, 25, 49]

• 集合解析

In [4]: {i * i for i in [1, 2, 3, 4, 1]}
Out[4]: {1, 4, 9, 16}

• 字典解析

In [5]: {k: v * v for k, v in [('a', 1), ('b', 2)]}
Out[5]: {'a': 1, 'b': 4}