壹拾伍

函数进阶

一、递归

​ 函数的递归调用，是一种特殊的嵌套调用，但是在调用一个函数的过程中，直接或者间接的调用了他自身。

​ 递归的核心: 递进的时候能够达到一个结果,问题规模越来越小(不一定要真正的达到)。

​ 递归函数不断地调用自身，就会很肯能会进入无限调用的死循环。同样是死循环，while循环就会进行下去，而递归调用就会在解释器设定的最大范围停止并报错“超出范围”。这是因为while循环的每次循环都只存在一个内存空间，而递归则是每一次都开辟一个新的空间，旧的空间不消失，这样就会占用大量的内存空间，所以就会强行结束。

​ 设置一个条件,能够让最后一次函数调用结束;

1.1 直接调用

​ 直接调用指的是：直接在函数内部调用函数自身。

import sys

# 修改递归层数
sys.setrecursionlimit(10000)
def foo(n):
    print('from foo',n)
    foo(n+1)
foo(0)

1.2 间接调用

​ 间接调用指的是：不在原函数体内调用函数自身，而是通过其他的方法间接调用函数自身。

def bar():
    print('from bar')
    foo()
    
def foo():
    print('from foo')
    bar()
    
bar()

​ 递归必须要有两个明确的阶段：

1. 递推：一层一层递归调用下去，进入下一层递归的问题规模都将会减小

2. 回溯：递归必须要有一个明确的结束条件，在满足该条件开始一层一层回溯。

   ​ 递归的精髓在于通过不断地重复逼近一个最终的结果。

1.3 为什么递归

​ 递归的本质就是干重复的活，但是仅仅是普通的重复，我们使用while循环就可以了……

二、内置函数

2.1 常用

1. bytes

res = '你好'.encode('utf8')
print (res)

b'xe4xbdxa0xe5xa5xbd'

2. chr()/ord()

​ chr()参考ASCII码表将数字转成对应字符；ord()将字符转换成对应的数字。

print(chr(65))
A
print(ord('A'))
65

3. divmod()

   ​ 分栏。

print(divmod(10, 3))
(3, 1)

4. enumerate()

   ​ 带有索引的迭代。

l = ['a', 'b', 'c']
for i in enumerate(l):
    print(i)
(0, 'a')
(1, 'b')
(2, 'c')

5. eval()

   ​ 把字符串翻译成数据类型。

lis = '[1,2,3]'
lis_eval = eval(lis)
print(lis_eval)
[1, 2, 3]

6. hash()

   ​ 是否可哈希。

print(hash(1))
1

2.2 了解

1. abs()

   ​ 求绝对值。

print(abs(-13))  # 求绝对值
13

2. all()

   ​ 可迭代对象内元素全为真，则返回真。

print(all([1, 2, 3, 0]))
print(all([]))
False
True

3. any()

   ​ 可迭代对象中有一元素为真，则为真。

print(any([1, 2, 3, 0]))
print(any([]))
True
False

4. bin()/oct()/hex()

   ​ 二进制、八进制、十六进制转换。

print(bin(17))
print(oct(17))
print(hex(17))
0b10001
0o21
0x11

5. dir()

   ​ 列举出所有time的功能。

import time
print(dir(time))
['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'clock', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'perf_counter', 'process_time', 'sleep', 'strftime', 'strptime', 'struct_time', 'time', 'timezone', 'tzname', 'tzset']

6. frozenset()

   ​ 不可变集合。

s = frozenset({1, 2, 3})
print(s)
frozenset({1, 2, 3})

7. globals()/loacals()

   ​ 查看全局名字；查看局部名字。

# print(globals())
def func():
    a = 1
#     print(globals())
    print(locals())


func()
{'a': 1}

8. pow()

print(pow(3, 2, 3))  # (3**2)%3
0

9. round()

print(round(3.5))
4

10. slice()

lis = ['a', 'b', 'c']
s = slice(1, 4, 1)
print(lis[s])  # print(lis[1:4:1])
['b', 'c']

11. sum()

print(sum(range(100)))
4950

12. _import_()

通过字符串导入模块。

m = __import__('time')
print(m.time())
1556607502.334777

​ 更多内置函数可以参考：https://docs.python.org/3/library/functions.html?highlight=built#ascii

三、面向过程编程

​ 面向过程编程是解决问题的一种思想，它与面向对象编程其实没有好坏之分。

​ 面向过程编程，核心是编程二字，过程指的是解决问题的步骤，即先干什么、后干什么、再干什么、然后干什么。

​ 基于该思想编写程序就好比在设计一条流水线，面向对称编程其实是一种机械式的思维方式。

​ 当我们写登录功能，我们首先需要输入账号、密码，然后认证两次密码是否相同，然后从数据库中读取密码验证用户密码输入是否正确，然后输入验证码……之后，我们就能够实现登录功能。这样把登录功能问题流程化，进而是解决问题的思路非常清晰。

​ 特点：上一个过程的输出必定是下一个过程的输入。

​ 优点：复杂的问题流程化，进而简单化。

​ 缺点：1 功能与功能之间不独立。2. 牵一发而动全身,不方便修改/扩展功能,可扩展性差。