[转载] Python 递归深入理解递归 Python递归剖析，绝对让你看懂！

参考链接： Python | print()中的结束参数

递归剖析递归的两个过程 return 返回值详解

递归思路二分法和递归尾递归递归练习题

递归剖析

递归真的很重要，之前学的时候，学的一知半解，以为真正了解，每次想到递归，就记得一句：返回给函数的调用者，嗯？函数调用者，你是说外部，还是内部啊？疑问太多了，还有就是被告知一句：递归能解决的问题，循环都能解决，所以就更加不重视递归了！直到接触算法后，在解决问题时，最快，最容易理解的解法就是递归，但是此时的递归却是看不太懂为什么要这样做！我先来说下，在算法中遇到可以用递归轻松完成的：希尔排序、归并排序、快速排序、反转链表及各种反转问题、二叉树的深度遍历、二叉树的各种题基本可以用、全排列…还有算法步骤里需要用到，太多了，所以，递归非常重要！“To iterate is human, to recurse divine 迭代是人，递归是神”，接下来，我也是看了很多算法书和视频，重点来整理下递归！

递归的两个过程

首先“递归”包括两个过程：递“去”的过程，“归”回的过程！先从一个简单的递归函数讲起

def di_gui(n):

print(n, "<===1====>")

if n > 0:

di_gui(n - 1)

print(n, '<===2====>')

di_gui(5) # 外部调用后打印的结果是？

递归的执行过程：首先，递归会执行“去”的过程，只需要满足终止条件，就会一直在函数内，带着更新的参数，调用函数自身，注意：到内部调用函数，以下面的代码不会被执行，而是暂停阻塞；此时随着函数每调用一次自身，还没有触发返回值和到达终止条件，等同于在原来的基础上不断“向下/向内”开辟新的内存空间，记住，每次调用一次函数，就不是处在同一空间（想象下《盗梦空间》里的情景，梦中梦，都是处于不同的空间）什么时候“递”去的过程结束？记住有两种情况>>> 一是：当前这层空间函数全部执行结束（终止条件），二是：执行到了return 返回值，直接返回；重点来理解下，首先是一，看上面的列子，例子中没有return，但是不断的调用后，最终还是停止了，因为最后n=0时，di_gi(0)还是去调用，从上往下执行时，遇到if n>0 它被终止了，走不下去了，表明，自己能到达的这层空间已经全部执行完毕；接下来请原地返回吧，返回到哪里？返回到函数的调用者，好我们返回到 di_gui(0)，把“到内部调用函数” 以下的代码全部执行完；执行完，看代码走到末尾，以为走出了最外层函数？注意了，此时它所处的空间并不是最外层哦，因为之前它被调用就在空间里面，所以回到的是 di_gui(1)的这一层空间，现在才是真正的开始“回”，所以继续把di_gui(1)的这一层空间，“到内部调用函数”以下的代码全部执行完，回到di_gui(2)的这一层空间…直到到达最开始从外部调用，让参数5进入的最外层空间位置，才走出来！表示《盗梦空间》里，柯布醒了！回来看下，代码输出的结果：5 4 3 2 1 00 1 2 3 4 5 （注意00这两个是在同一层空间哦）从内存角度（本质）来分析：每调用一次函数，都会单独开辟一份栈帧空间，递归函数就是不停的开辟和释放栈帧空间的过程，具体来理解下：一个普通函数从执行到结束，就是一个开辟空间和释放空间的过程；而递归函数是在调用最外层函数时，先开辟一个最外层空间，每调用一次自身，就会在最外层空间内，再自己开辟本次的空间（所以递归耗内存）（还有一种说法是，不断的本次空间的基础上再开辟空间，等于是不断的嵌套，其实这两种说法本质上是一样的，因为信息都可以做到不共享），空间之间如果不通过参数传递或者用return 返回值，信息是不共享的，如下图↓↓↓

递归的数据共享情况：递归每一层间的数据是独立的，不共享，但是可以通过参数或者返回值来形成共享，参数具体在传入的是“引用类型”（比如列表）递归必须要有一个出口，如果没有出口就会重复调用，不断的开辟栈帧空间

# 获取最大递归层数：

import sys

res=sys.getrecursionlimit()

print(res) # 结果：1000

# sys.setrecursionlimit(800) 可以自己设置最大递归层数

解释含有 return 返回值的递归，记住 return的返回流程是：先计算，再返回，来看下一段求阶乘的代码：

def jie_cheng(n):

if n <= 1:

return 1

return n * jie_cheng(n - 1)

print(jie_cheng(5))

return 是返回到函数调用者，递归函数和普通函数也是一样的，所以递归最后一层空间走到尽头（一是：指向完毕，二是：遇到return，回顾一下而已）遇到return，就要开始返回了，返回到它的调用者（即是阻塞的位置），直到回到最外层空间如果上面的内容看懂了的话，试着解析下：下面这段代码的执行流程

def get_num(num):

if num > 2:

get_num(num - 1)

print(num)

get_num(4) # 输出结果为：2 3 4

代码变化一下：

def get_num(num):

if num > 2:

get_num(num - 1)

else:

print(num)

get_num(4) # 输出结果为 2

'''

解析一下：加了else后，首先代码区有两个分支，

在num>2时，执行会有递归，当n=4 是开辟一层空间；

n=3时开辟一层空间，此时 get_num(2) 再开辟一个空间，

当它从上往下执行过程中，在他本层空间遇到if num>2 不成立，所以走分支 else，直接打印出来；

此时代码还没结束，回到上一层空间，num=3, num>2 已经进入了if 不会走else，

num=4 也不会走else，所以这两层空间没有值输出！

'''

return 返回值详解

上面这一大部分，就算是递归入门了，接下来才刚刚开始哦！还要继续讲 return ；先来看下这几段代码：求全排列的一部分递归代码，试着分别写出运行结果，并依次分析原因↓↓↓

# 例1：

def fullpermutation(list):

if list is None:

return None

if len(list) == 1:

return [list]

res = []

pivot = list[0]

remain = fullpermutation(list[1:])

print(remain)

print(fullpermutation([1, 2, 3]))

'''

输出结果为：

[[3]]

None

'''

递归只会在两种情况下触发“回”的过程，上述是在最后一层空间是碰到了return，所以给回到它的调用处（阻塞处），因为return会给调用者返回一个值，所以在本层空间，remain接收到了一个值：[[3]]；接着执行下面的代码，即是打印remain，所以输出“[[3]]”，执行完print，等于回到了上一层空间，又到了调用处（阻塞处），那么这层空间还有返回值吗？答案是没有，所以“最后一层空间是碰到了return 给它返回的值只会给最后一层使用”，所以接下来两层都是打印空！

# 例2：

def fullpermutation(list):

if list is None:

return None

if len(list) == 1:

return [list]

res = []

pivot = list[0]

return fullpermutation(list[1:])

print(fullpermutation([1, 2, 3]))

'''

输出结果为：

[[3]]

'''

这次是，在最后一层返回时，获得了一个返回值 [[3]] ，然后回到上一层时，前面又有return 表示需要把本层的返回值，返回到上层的接收处，重复，直到回到最外层，这个从底层传上来的返回值，一直传到了最外层，所以才打印出来的，只有最后一层，但是每次一层都获得了返回值，和例子1 后面两层没有返回值是不同的哦！

# 例3：

def fullpermutation(list):

if list is None:

return None

if len(list) == 1:

return [list]

res = []

pivot = list[0]

remain = fullpermutation(list[1:])

print(list)

print(fullpermutation([1, 2, 3]))

'''

输出结果为：

[2, 3]

[1, 2, 3]

None

'''

最后一层碰到return，触发会的过程，回到调用处，执行阻塞处下面的代码，打印list，这个list是什么？它就是本层空间参数的规模（因为代码写的是规模不断变小从[1,2,3]>>>[2,3]>>>[3]）,显然，从最后一层回到上一层，此时规模是[2,3]，所以打印list 就是[2, 3]；接着继续回到上一层，即是最外层，规模是[1,2,3]，所以打印[1, 2, 3]，最后的None是因为最外层函数，没有返回值，所以才打印出None

# 例4：

def fullpermutation(list):

if list is None:

return None

if len(list) == 1:

return [list]

res = []

pivot = list[0]

remain = fullpermutation(list[1:])

return list

print(fullpermutation([1, 2, 3]))

'''

输出结果为：

[1, 2, 3]

'''

依照上面的步骤，触发回的过程，只要没有到达最外层，return list 返回本层的规模（参数规模），那么这个返回值就会给本层的接收者 remain 不可能给最外层的接收者，虽然这里没有打印 remain的值，但是这里的remain和第一个列子中的remain，后面层数是有返回值的哦（下面例子就会体现），本例，返回到最外层时，list的本层规模为 [1,2,3] 最外层接收者接收到，然后打印出来，所以是[1,2,3]

# 例5：

def fullpermutation(list):

if list is None:

return None

if len(list) == 1:

return [list]

res = []

pivot = list[0]

remain = fullpermutation(list[1:])

print(remain)

return list

print(fullpermutation([1, 2, 3]))

'''

输出结果为：

[[3]]

[2, 3]

[1, 2, 3]

'''

看上面的例子，这次我们是打印了 remain，因为返回的过程中，指向阻塞处（调用处）下面的代码，每次return list 即是在本层返回当前的参数规模，所以 remain 是能接收本层的返回值的，所以会打印 [[3]] ，[2, 3] ；最后 [1, 2, 3] 是最外层打印的

# 例6：

def fullpermutation(list):

if list is None:

return None

if len(list) == 1:

return [list]

res = []

pivot = list[0]

remain = fullpermutation(list[1:])

print(remain)

print(list)

return list

print(fullpermutation([1, 2, 3]))

'''

输出结果为：

[[3]]

[2, 3]

[1, 2, 3]

'''

这个，就是所有的融合；通过上面的代码我们来总结下return的返回值：最后一层遇到的return 需要执行回的过程，此时的返回值值会返回给最后的调用处的接收者；然后执行阻塞处下面的代码时，如果又遇到return 这里的返回值，如果没有到达最外层，都是给本层的接收者！为什么要大费周章的讲这个，是因为我们在写递归时，往往不清楚return 要怎么写，已及它的返回值是什么？接下来就要看下return 如何解决问题的请用递归完成一个字符串的反转，输入字符串“abcd”，完成翻转成“dcba” 除了递归，我们可以直接用字符串的切片来完成，如下，但是这里是要讲递归的思想，不体现方法优劣！

s="abcd"

print(s[::-1])

想一下递归的思路该怎么做？思路一：按照上面的例子，不断的划分子规模，我们选的是划分原字符串的规模，都是往后截取的，比如第一次参数s=“abcd” 我们取参数s[1:] ，不断调用函数，每次传入参数为：‘bcd’ ‘cd’ ‘d’ ，这样最后一层返回d 我们能拿到最后一个值，然后最后一个返回值d 加上当前规模的第一个值，就完成了反转，具体代码如下：

def str_reverse(s):

if len(s) <= 1: # 递归出口

return s

# last = str_reverse(s[1:])

# return last + s[0]

return str_reverse(s[1:]) + s[0] # 每次返回最后一层的值，加上当前规模的第一个值

思路二：改变下子规模，我们这次不划分原字符串，而是从它的索引下手，传入最后一个元素的索引，不断去递归索引的值，这时，变的是end的值，从 3 到 2 1 0，到0时触发回的过程，返回当前索引的值，即是 a （不断向前取值），这时我们再加上当前层的s，因为没有划分s所以s每一层都是等于‘abcd’的，我们每次取当前end索引指向的字符串的值，等于从前往后遍历字符串 ‘abcd’ ，两部分链接起来，就完成了反转：每次的返回值为 a, ba , cba, dcba,

def reve(str, end):

if end == 0:

return "" + str[0]

last = str[end] + reve(str, end - 1)

return last

s = "abcd"

print(reve(s, len(s) - 1))

两种做法都用到return，而是还有重要的递归思路，下面就来看看递归要用什么思路来解来试下“反转链表”如何用递归做，首先对于一个单链表，要对它反转，我们的思路依旧可以通过不断向后划分子规模，找到它的最后一个结点，然后从后往前依次改变每个结点的指向，让最初的头结点变成尾结点，让它最后指向None；那么具体步骤是：用递归找到最后一个结点，我们可以通过前一个结点的next区域，不断递归，找到下一个结点，直到当前结点的next是None，说明它就是最后一个结点，这也是我们递归的出口，那么依次让它返回，同时改变指向，就完成了，具体看下面的图解：

class ListNode:

def __init__(self, x):

self.val = x

self.next = None

class Solution:

def ReverseList(self, pHead):

if pHead is None: # 判断传入的头结点是否为空

return None

if pHead.next is None: # 如果只有一个结点，直接返回结点；同时也是递归的出口

return pHead

last_node = self.ReverseList(pHead.next) # last_node永远只接收到了最后一个结点

pHead.next.next = pHead # 后一个结点，指向前一个结点

pHead.next = None # 前一个结点，在不同的层，先指向None，如果到达最外层也会指向None

return last_node # 最后返回最后一个结点，表示反转成功

到达最后一层，触发回的过程，返回 last_node 结点给最后第四层，执行阻塞处下面的代码，因为pHead.next.next 是None，它不用改变也行，直接到 return last_node 把 last_node给第三层用… 第三层获得 last_node ，执行阻塞处下面的代码，改变指向，pHead.next.next 是“5结点”，它的指针指向 pHead，即是上一个结点，然后上一个结点指向None；因为这里并不需要用一个temp 来保存前一个指针信息，表面上是断开链接，会丢掉数据，其实不会丢掉，因为他们不再同一层；可以用temp先保存前一个结点的数，这属于递归的写，在我的文章>>>反转链表多种解法有提到，这里不细说！直到回到最外层，起初的头结点，自然会指向None，最后返回 last_node即可这才是链表反转递归的详细过程，果然和我开始理解的不一样，当初怎么都无法理解，直到用断点调试，才发现真正的过程，是这样，大家可以用断点调试下，看下代码的具体过程，下面是测试代码：

class ListNode:

def __init__(self, x):

self.val = x

self.next = None

class Solution:

def ReverseList(self, pHead):

if pHead is None:

return None

if pHead.next is None:

return pHead

last_node = self.ReverseList(pHead.next)

print(last_node.val)

pHead.next.next = pHead

pHead.next = None

return last_node

def print_list(self, node): # 打印测试

if node is None:

return None

while node:

print(node.val, end="")

node = node.next

print()

if __name__ == '__main__':

n1 = ListNode(1) # 依次实例5个结点

n2 = ListNode(2)

n3 = ListNode(3)

n4 = ListNode(4)

n5 = ListNode(5)

n1.next = n2 # 依次将结点链接起来，形成一个链表

n2.next = n3

n3.next = n4

n4.next = n5

n5.next = None

obj = Solution()

print(obj.ReverseList(n1).val)

# obj.print_list(n1) # 1 2 3 4 5

# obj.print_list(obj.ReverseList(n1)) # 5 4 3 2 1

递归思路

思想： 1.找到当前这个值与上一个值的关系 2.找到程序的出口有个明确的结束条件 3.假设当前功能已经完成每次进入更深一层递归时，问题规模相比上次递归都应有所减少递归思路：（1）找重复：看哪一部分是实现函数的变化；每次进入更深一层递归时，问题规模相比上次递归都应有所减少（2）找变化：变化的量应该作为参数（3）找边界（出口）：终止条件递归可以分为：（1）直接量+小规模子问题（2）多个小规模子问题（3） “切蛋糕”思维（4）找递推公式，等价交换公式

二分法和递归

# 二分法一定是在排序好的数据里使用

lst = [33, 22, 44, 55, 66, 88, 77, 99, 101, 238, 345, 456, 567, 678, 789]

n = 76

lst.sort()

left = 0

right = len(lst) - 1

while left <= right: # 条件是开头<=结尾

middle = (left + right) // 2

if lst[middle] > n: # 每次用对折后，中间的数和查找对象比较

right = middle - 1

elif lst[middle] < n:

left = middle + 1

elif lst[middle] == n:

print("找到了")

break

else:

print("这个数不在列表中")

# 递归函数来做

lst = [22, 33, 44, 55, 66, 77, 88, 99, 101, 238, 345, 456, 567, 678, 789]

def func(n, left, right):

if left <= right: # 边界

mid = (left + right) // 2

if n > lst[mid]:

left = mid + 1

func(n, left, right) # 递归的入口,目的是再确定一次中间的位置

elif n < lst[mid]:

right = mid - 1

func(n, left, right)

elif n == lst[mid]:

print("找到了")

return # 递归出口

else:

print("没有这个数")

return # 递归的出口

func(66, 0, len(lst) - 1)

# 升级：如果找到了要求的数，请返回它的索引

lst = [22, 33, 44, 55, 66, 77, 88, 99, 101, 238, 345, 456, 567, 678, 789]

def func(n, left, right):

if left <= right: # 边界

mid = (left + right) // 2

if n > lst[mid]:

left = mid + 1

return func(n, left, right) # 每一层都要返回给上一层的调用者

elif n < lst[mid]:

right = mid - 1

return func(n, left, right)

elif n == lst[mid]:

print("找到了")

return mid # 多层函数只会将返回值返回给上一层的调用者

else:

print("没有这个数")

return -1

print(func(66, 0, len(lst) - 1))

尾递归

尾递归（自己调用自己，且非表达式：把值放到参数中算）

>>>求斐波那契数列第n位是几？(尾递归做法)

def feibo(num, res, temp):

#使用尾递归法求解斐波那契数量的第num个数字

if num == 0:

return res

else:

return feibo(num - 1, temp, res + temp)

print(feibo(10,0,1))

# 直接递归尾递归与循环的对比

import time

def Fib_recursion(num):

'''

直接使用递归法求解斐波那契数量的第num个数字

'''

if num < 2:

return num

return Fib_recursion(num - 1) + Fib_recursion(num - 2)

def Fib_tail_recursion(num, res, temp):

'''

使用尾递归法求解斐波那契数量的第num个数字

'''

if num == 0:

return res

else:

return Fib_tail_recursion(num - 1, temp, res + temp)

def Fib_circle(num):

'''

直接使用循环来求解

'''

a = 0

b = 1

for i in range(1, num):

c = a + b

a = b

b = c

return c

if __name__ == '__main__':

num_list = [5, 10, 20, 30, 40, 50]

for num in num_list:

start_time = time.time()

print(Fib_recursion(num))

end_time = time.time()

print(Fib_tail_recursion(num, 0, 1))

end_time2 = time.time()

print(Fib_circle(num))

end_time3 = time.time()

print('正在求解的斐波那契数字下标为%s' % num)

print('直接递归耗时为：', end_time - start_time)

print('尾递归调用耗时为：', end_time2 - end_time)

print('直接使用循环耗时为：', end_time3 - end_time2)

递归练习题

>>>打印f-e的数：

def pri(f, e):

if f > e:

return

else:

print(f)

return pri(f + 1, e)

pri(1, 6)

>>>求一个列表的和：

def sum_lis(li, f): # 如果单独是传入一个列表，它体现不了变化

"""

:param li: 传入一个列表

:param f: 列表起始位置

:return: 列表和

"""

if f == len(li) - 1: # 表示起始位置也是结束位置，即只有一个元素

return li[f]

return li[f] + sum_lis(li, f + 1)

print(sum_lis([1, 2, 3, 4, 5], 0))

# 多引入一个变化的参数，可以想到第一个元素加上剩下的元素，规模不断变小

# 需求:求 1+2+3+4........100 的和

num = 1

count = 0

while num <= 100:

count += num

num += 1

print(count)

'''

思路：

sum(1) + 2 +3.....100

sum(2) + 3........100

sum(3) + 4........100

...

sum(98)+99+100

sum(99) + 100

sum(100)

sum(100) = sum(99) + 100

sum(99) = sum(98) + 99

sum(98) = sum(97) + 98

.....

sum(2) = sum(1) + 2

sum(1) = 1

'''

# 用递归函数解决

def sum(num):

if num == 1: # 出口

return 1

return num + sum(num - 1) # 一直返回sum(num-1)+num，每次递归调用，有return才能有返回值

print(sum(100))

>>>需求：打印斐波那契数列

def fibo(num): # 参数是表示第n个斐波那契数，函数整体表示获取斐波那契数列中第n个数字的值

if num == 1 or num == 2: # 第一个和第二个都是1

return 1 # 返回1，出口

return fibo(num - 1) + fibo(num - 2) # 规律，后一项加上后两项，就等于斐波那契数列第n个数字的值

if __name__ == '__main__':

list_num = [] # 创建一个空列表，开始

for i in range(1, 21): # 遍历1-20

list_num.append(fibo(i)) # 注意这里开始调用函数，获得一个斐波那契数字，将获取到的值填充到list_num

print(list_num)

# 最佳解法：

def fei_bo(n):

if n <= 1:

return (n, 0)

else:

(a, b) = fei_bo(n - 1)

return (a + b, a)

print(fei_bo(5))

# 这里是线性的解法，不再重复计算前一项已知的数

# 求最大公约数

def maxg(m, n):

if n == 0:

return m

return maxg(n, m % n)

print(maxg(6, 0))

# 最大公约数：

# 如果m%n=0 则n是m的最大公约数；例如4%2=0 则2是最大公约数

# 如果m%n=K 则 n%k=?0 >>> f(m,n)=f(n,m%n)

>>>用递归实现列表排序：

def ins(li, k):

if k == 0:

return

# 对前K个元素进行排序

ins(li, k - 1)

# 把位置K的元素插入到前面的部分

x = li[k]

index = k - 1

while x < li[index]:

li[index + 1] = li[index]

index -= 1

li[index + 1] = x

print(li)

ins([1, 4, 3, 2], 3)

>>>需求：递归实现遍历目录

import os

def get_alldirfile(source_path): # 定义一个函数获取用户输入的路径名下所有目录和文件

if not os.path.exists(source_path): # 判断用户输入的目录是否存在

return # 不存在，直接返回，结束该函数，找到一个出口

list_name = os.listdir(source_path) # lisdir获取所有目录，并全部放到一个列表中

for flie_dirname in list_name: # 遍历下所有的文件目录名

abs_path = os.path.join(source_path, flie_dirname) # 拼接成绝对路径

# 判断下一级是否是目录还是文件，是文件结束，是目录继续深入，直到是文件结束

if os.path.isfile(abs_path): # 是文件

print("file_path:%s" % (abs_path))

# 也可进行复制操作，open(abs_path,"w",encoding="utf-8")

if os.path.isdir(abs_path):

get_alldirfile(abs_path) # 递归函数

if __name__ == '__main__':

path = r"F:\日语\快乐50音"

get_alldirfile(path)

# 优化

import os

def file_get(file_path, n):

list_file = os.listdir(file_path)

for file in list_file:

abs_file = os.path.join(file_path, file)

if os.path.isdir(abs_file):

print("\t" * n, file)

file_get(abs_file, n + 1)

else:

print("\t" * n, file)

file_get("D:\KuGou", 1)

[转载] Python 递归深入理解递归 Python递归剖析，绝对让你看懂！相关推荐

python语言的理解-使用Python语言理解递归
递归一个函数在执行过程中一次或多次调用其本身便是递归,就像是俄罗斯套娃一样,一个娃娃里包含另一个娃娃. 递归其实是程序设计语言学习过程中很快就会接触到的东西,但有关递归的理解可能还会有一些遗漏,下面 ...
【1.1正则表达式】Python核心编程（第三版）猴子都能看懂的笔记
文章目录正则表达式起始和结尾部分指定单词边界匹配限定范围和否定正则常用符号使用圆括号指定分组扩展表示法扩展表示法 1.3正则表达式和Python语言常见的正则表达式属性 compile ...
从零开始一起学习SLAM | 理解图优化，一步步带你看懂g2o代码
点击上方"小白学视觉",选择加"星标"或"置顶" 重磅干货,第一时间送达小白:师兄师兄,最近我在看SLAM的优化算法,有种方法叫" ...
python反转字符串递归怎么理解_Python使用递归反转字符串
要递归地解决一个问题,找到一个容易解决的小问题,并通过将问题分解为其自身的越来越简单的版本来找出如何解决这个小问题. 你倒弦的第一件事是什么?第一件事是什么?你得到了字符串的最后一个字符,对吧? 所以 ...
python颜色按红黄蓝递归_用Python给高斯的帽子换颜色 - 你妈妈都能看懂
首先让我祭出一张数学王子高斯的照片,这位印在德国马克上的神人有多牛呢? 他是近代数学的奠基人之一,与牛顿, 阿基米德并称顶级三大数学家,随便找一个编程语言的数学库,里面一定有和他名字相关的一堆函数. ...
python语言的理解-初学Python语言者必须理解的下划线
下划线(_)在Python语言中有特殊作用. 在大多数编程语言中,下划线是命名变量或者函数名称时的连字符,但是,在Python语言中,不仅如此.如果你是一名Python程序员,对于诸如 _ in ra ...
python【Matlibplot绘图库】Animation动画（真の能看懂~！）
文章目录 1 代码 2 效果 3 解释 1 代码 from matplotlib import pyplot as plt from matplotlib import animation impor ...
python【Matlibplot绘图库】画图种类（真の能看懂~！）
文章目录 1 Scatter散点图 2 Bar柱状图 3 Contours 等高线图 4 Image 图片 5 3D 数据 1 Scatter散点图 import matplotlib.pyplot ...
python【Matlibplot绘图库】基本使用（真の能看懂~！）
文章目录 1 基本用法 2 figure图像 3 设置坐标轴1 4 设置坐标轴2 5 Legend图例 6 Annotation标注 7 tick能见度 1 基本用法 import matplotli ...
【Leetcode】Python实现字符串转整数 (atoi) - 详细备注，保证小白看懂
''' 6 字符串转整数(atoi) 实现 atoi,将字符串转为整数.在找到第一个非空字符之前,需要移除掉字符串中的空格字符.如果第一个非空字符是正号或负号,选取该符号,并将其与后面尽可能多的连续的 ...

[转载] Python 递归深入理解递归 Python递归剖析，绝对让你看懂！

[转载] Python 递归深入理解递归 Python递归剖析，绝对让你看懂！相关推荐

最新文章

热门文章

[转载] Python 递归 深入理解递归 Python递归剖析，绝对让你看懂！

[转载] Python 递归 深入理解递归 Python递归剖析，绝对让你看懂！相关推荐

最新文章

热门文章

[转载] Python 递归深入理解递归 Python递归剖析，绝对让你看懂！

[转载] Python 递归深入理解递归 Python递归剖析，绝对让你看懂！相关推荐