计算机基础知识16

递归函数

递归：直接或者间接的调用其他函数

def index():
    print('from index')
    func()
def func():
    print('from func')   # 递归，超过递归深度，报错
    index()
func()
'''递归在实际编码中是不允许出现的，一旦出现了无限递归就会直接报错'''

count = 1   #全局名称对象
def index:
    global count   #在def函数里，在内部修改全局变量需加global
    print(count)
    count += 1     # 修改
    index()        # 引用自己的函数，递归

实际用法：同学1不知道，比同学2大两岁，同学2不知道，比同学3大两岁......最后一个同学                    18岁，推算同学1的实际年龄

# age(5) = age(4) + 2
# age(4) = age(3) + 2 ...
# age(1) = 18
def age(n):
    if n == 1:
        return 18
    return age(n-1) + 2  # n=2---》age(1)---->age(2)----->age(3)。。。
res=age(5)    # 求第5个人的年龄
print(res)

# 递推：一层一层的往下寻找答案

# 回溯：通过最后一个结果往回寻找最开始的那个答案

# 伪代码：代码能够表达基本逻辑，但是不能够运行

递归是必须有结束条件！！！！

递归函数练习题

l = [1, [2, [3, [4, [5, [6, [7, [8, [9, [10, [11, [12, [13, [14, ]]]]]]]]]]]]]]
'''循环打印出来列表中得数字，但是不打印列表'''
# 1. 先循环l列表，然后判断此时循环的数据是数字还是列表? 如果是数字就打印
# 2. 循环第二次的时候，还是需要判断此时的数据是数字还是列表，如果是数字就打印，否则就循环
for i in l:     
     if type(i) is int:      # 1. 判断此时循环的数据是数字还是列表
         print(i)
     else:                   # 否则就是列表，循环列表
         for j in i:         #  判断此时循环的数据是数字还是列表             
             if type(j) is int:
                 print(j)
             else:           # 否则就是列表，循环列表                
                for k in j:
                    if type(k) is int:
                       print(k)
                     else:        # 否则就是列表，循环列表                 
                         for v in k:
                            ...

#### 递归实现
def get_list(l):
    for i in l:
        if type(i) is int:
            print(i)
        else:
            get_list(i)
get_list(l)

除此之外，递归还可以运用于迷宫问题、八皇后问题、汉诺塔问题、阶乘问题等等.....

算法之二分法

算法：就是解决问题的高效办法     # 算法中的二分法、冒泡排序、选择排序、堆排序、等..

# 二分法的使用场景：让你在一个列表中查找某个数字是不是存在

l = [11, 2, 3, 43, 55, 67, 23, 45, 45, 88, 99, 66,]
'''查找66这个数字是否在列表l中'''
# 思路：遍历列表l一个一个去比较，如果比较到了，就是找到了，否则，就是没找到   
for i in l:
  if i == 66:
      print('找到了')

二分法的原理：1. 列表必须先排序(从小到大，从大到小)
                          2. 折半查找

l = [11, 2, 3, 43, 55, 67, 23, 45, 45, 88, 99, 66,]
l.sort()     # 1. 排序
target_num = 66 
def my_half(l,target_num):
    if len(l) == 0:        # 假如值不在列表内
        print('没找到')
        return    
    middle_index = len(l) // 2  # 向下取整 5 // 2 == 2  6 // 2 == 3
    if target_num > l[middle_index]:
        l_right = l[middle_index+1:]  
        print(l_right)
        my_half(l_right, target_num)   # 递归，引用自己函数，一直找到为止    

    elif target_num < l[middle_index]:
        l_left = l[:middle_index]
        print(l_left)
        my_half(l_left, target_num)
    else:
        print('找到了')
my_half(l, target_num)

算法之冒泡算法

#对比两个数大小，如果前面比后面大，那么就交换位置

for i in range(len(list1)-1):
    for x in range(i+1,len(list1)):
        if list1[i] > list1[x]:
            list1[x],list1[i] = list1[i],list1[x]
print(list1)

三元表达式

# 写一个比较两个数大小的函数，返回大的
def my_max(a, b):
    if a >b:
        return a
    else
    	return b

def my_max(a, b):
    return a if a > b else b
res = my_max(1, 2)

对于只有二选一的情况，我们推荐使用三元表达式

语法结构: res = 条件成立之后的结果 if 条件 else 条件不成立之后的结果

# res = '不出去玩' if '下雨' else '出去玩'

# res = '扯淡' if 2 > 10 else 10

# print(res)

"""还支持嵌套"""
res = 2 if 2 > 10 else ( 10 if False else (100 if 10 > 5 else (2 if False else 1)))
print(res)

## 不推荐写太多的嵌套，两层就够了，超过两层了，建议不这样写，面试时：成数非常多

列表表达式

names_list = ['kevin', 'jerry', 'tank', 'oscar']
"""把列表中得每一个名字后面都拼上后缀_SB"""
new_list = [] # 存放拼接之后的人名
for name in names_list:
    res = name + '_SB'
    new_list.append(res)
print(new_list)    # ['kevin_SB', 'jerry_SB', 'tank_SB', 'oscar_SB']

# 列表生成式
res = [ name + '_SB' for name in names_list]
print(res)

names_list = ['kevin', 'jerry', 'tank', 'oscar']
# 列表中得每一个名字都拼接上后缀:_SB,除jerry之外

new_list = []
for name in names_list:
    if name == 'jerry':
        new_list.append(name)
        continue
    else:
        new_list.append(name+'_SB')
print(new_list)

# 列表生成式如何写
# res = [name+'_SB' for name in names_list if name != 'jerry' ]
res = [name+'_SB' if name != 'jerry' else name for name in names_list]
print(res)
# 用三元表达式可加else，走for循环

字典生成式、集合生成式(了解)

l1 = ['name', 'age', 'gender']
l2 = ['oscat', 18, 'male']
# d= {'name':oscat, age:18, 'gender':'male'}
d = {}
for i in range(len(l1)):
    d[l1[i]] = l2[i]
print(d) # {'name': 'oscat', 'age': 18, 'gender': 'male'}

补充一个方法：enumarate

那么字典生成式为：

l1 = ['name', 'age', 'gender']
for i, j in enumerate(l1):
    # (0, 'name')
    # (1, 'age')
    # (2, 'gender')
    print(i, j)

l1 = ['name', 'age', 'gender']
l2 = ['oscat', 18, 'male']
d = {l1[i]:l2[i] for i, j in enumerate(l1)}
print(d)        # {'name': 'oscat', 'age': 18, 'gender': 'male'}

"""没有元组生成式"""

s = {i for i, j in enumerate(l1)}     # 生成器
print(s)

今日思维导图：