纸上得来终觉浅,绝知此事要躬行。
递归的概念很简单,如果函数包含了对其自身的调用,该函数就是递归的。拗口一点的定义是,如果一个新的调用能在相同过程中较早的调用结束之前开始,那么个该过程就是递归。
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}