python中的递归算法

递归算法：

递归算法是一种直接或者间接地调用自身算法的过程。在计算机编写程序中，递归算法对解决一大类问题是十分有效的，它往往使算法的描述简洁而且易于理解。

递归算法解决问题的特点：

(1) 递归就是函数在调用阶段直接或间接的又调用自身。

(2) 在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。

(3) 递归算法解题通常显得很简洁，但递归算法解题的运行效率较低。所以一般不提倡用递归算法设计程序。

递归分为两个阶段:

(1):回溯:就是一次次重复的过程,这个重复的过程必须建立在每一次重复问题的复杂度都应该下降直到有一个最终的结束条件。

(2):递推:一次次往回推导的过程。

递归函数不要考虑循环的次数 只需要把握结束的条件即可

def recursion(i):   #定义函数
    print(i)
    if i/2 > 1:   #判断递归条件，退出
        re = recursion(i/2)  #递归函数自身
        print('返回值:',re)
    print('上层递归值：',i)
    return i     #返回值
recursion(10)


"""
运行原理：首先运行函数传参10给函数，打印10，判断条件是否满足，
满足递归函数参数值为（10/2）5，打印i的值5，等递归到1.25时，判断条件不满足后，
才打印上层递归的值，此时的值为1.25，return递归最后一层的值1.25，退出最后一层递归，
继续一层层退出递归，最后返回最上层递归值结束函数。

"""

# 输出结果为：
10
5.0
2.5
1.25
上层递归值： 1.25
返回值: 1.25
上层递归值： 2.5
返回值: 2.5
上层递归值： 5.0
返回值: 5.0
上层递归值： 10

python二分算法：

二分算法是能够更高效解决问题的方法：

二分查找操作的数据集必须是一个有序的数据集。开始时，先找出有序集合中间的那个元素。如果此元素比要查找的元素大，就接着在较小的一个半区进行查找；反之，如果此元素比要找的元素小，就在较大的一个半区进行查找。在每个更小的数据集中重复这个查找过程，直到找到要查找的元素或者数据集不能再分割。

二分查找能应用于任何类型的数据，只要能将这些数据按照某种规则进行排序。然而，正因为它依赖于一个有序的集合，这使得它在处理那些频繁插入和删除操作的数据集时不太高效。这是因为，对于插入和操作来说，为了保证查找过程正常进行，必须保证数据集始终有序。相对于查找来说，维护一个有序数据集的代价更高。此外，元素必须存储在连续的空间中。因此，当待搜索的集合是相对静态的数据集时，此时使用二分查找是最好的选择。

二分算法实质上是不断地将有序数据集进行对半分割，并检查每个分区的中间元素。

# 二分法查找要求：查找序列必须是有序序列
# 查找156在lst中的位置
lst = [1, 4, 5, 6, 8, 9, 11, 15, 17, 18, 19, 45, 49, 98, 101, 156, 178, 199]
def binary_search(lst, n, left, right):
    if left > right:
        print("没有这个数")
        return -1
    middle = (left + right) // 2
    if n < lst[middle]:
        right = middle - 1
    elif n > lst[middle]:
        left = middle + 1
    else:
        return middle
    return binary_search(lst, n, left, right)
left = 0
right = len(lst) - 1
print(binary_search(lst, 156, left, right))  # 15 查找的156在列表的第15位。

python三元表达式：

使用一行代码快速判断，替换复杂的多行if语句，使得代码简单可维护。

"""
三元表达式固定表达式
    值1 if 条件 else 值2
        条件成立 值1
        条件不成立 值2
"""

# 普通模式判断大小：
x=2
y=3
if x > y:
    print(x)
else:
    print(y)

# 三元表达式比大小
x = 2
y = 3
res = x if x > y else y    
print(res)

python列表生成式:

列表生成式是Python内置的非常简单却强大的可以用来创建list的生成式。列表生成式的结构是在一个中括号里包含一个表达式,然后是一个for语句,然后是0个或多个for或者if语句。列表表达式可以是任意的,意思是你可以在列表中放入任意类型的对象。返回结果将是一个新的列表,在这个以if和for语句为上下文的表达式运行完成之后产生。运用列表生成式，可以快速生成list，可以通过一个list推导出另一个list，而代码却十分简洁。

# 生成[1x1, 2x2, 3x3, ..., 10x10]

# 不用列表生成式：
l = []
for x in range(1, 11):
    l.append(x * x)
print(l)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]


# 使用列表生成式：
l = []
res = [x * x for x in range(1, 11)]
print(res)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]


"""
先for循环依次取出列表里面的每一个元素
然后交由if判断  条件成立才会交给for前面的代码
如果条件不成立 当前的元素 直接舍弃
"""

python字典生成式：

# 例：
my_dict = {"a": 1, "b": 2, "c": 3}
print(my_dict)  # {'a': 1, 'b': 2, 'c': 3}

匿名函数：

匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：有些函数在代码中只用一次，而且函数体比较简单，使用匿名函数可以减少代码量，匿名函数是没有名字的函数，它的特点是临时存，用完就没了。

#普通函数：
def calc(x,y):
    return x**y
print(calc(x=2,y=5))



# 换成匿名函数
calc = figure x,y:x**y
print(calc(2,5))

函数的常用的内置方法：简单的提一下：

abs():

绝对值函数。如abs（-1）= 1

# 参数：
# x -- 数值表达式，可以是整数，浮点数，复数。

# 返回值：
# 函数返回 x（数字）的绝对值，如果参数是一个复数，则返回它的大小。


>>> abs(-10)
10
>>> f = abs
>>> f(-1)
1
>>> abs=id
>>> abs(1)
1869788224

"""
以abs()函数为例，展示两个特性。一是，内置函数是可以被赋值给其他变量的，
同样也可以将其他对象赋值给内置函数，这时就完全变了。所以，内置函数不是
Python关键字，要注意对它们的保护，不要使用和内置函数重名的变量名，这
会让代码混乱，容易发生难以排查的错误。
"""