python 基础篇 16 递归和二分数查找与编码补充回顾

编码回顾补充:

 

 

回顾编码问题:
        编码至关于密码本,关系到二进制与看懂的文字的的对应关系.
    最先期的密码本:
        ascii码:只包含英文字母,数字,特殊字符.
            0000 0001:
             'fjdskal 我发'
            字符:组成你看到的内容的最小单位就是字符.
            位:二进制中占有的位置,就是位.
            字节:8位表示一个字节.
            对于ascii码,一个字符是用8位一个字节去表示.
            A: 01000001
        unicode 万国码:将全世界全部的文字都给我汇总到一块儿.
            起初:unicode:
                一个字符用16位表示.
                A: 0000 0000 0000 0010
                中:0000 0000 1000 0010
            最终unicode:
                一个字符用32位表示.
                A: 0000 0000 0000 0010 0000 0000 0000 0010
                中:0000 0000 1000 0010 0000 0000 1000 0010
            浪费,占用资源.
        utf-8: 最少用8位表示一个字符.对unicode升级,
                    A: 01000001
             欧洲文字: 0000 0000 1000 0010
             亚洲文字: 0000 0010 0000 0000 1000 0010
        gbk: 国标
            英文字母:一个字节表示.中文两个字节表示.
            A: 01000001
            中:0000 0000 1000 0010

    前提:
            文件的存储和传输 不能用unicode编码
            除了unicode 剩下的编码方式不能直接识别.
        python3x版本.
        int
        str  ----> 在内存中用的unicode
        bytes类型
        list
        bool
        dict
        set
        tuple

        英文:
            str:
                表现形式: s = 'oldboy'
                内部编码: unicode
            bytes:
                表现形式: b1 = b'oldboy'
                内部编码: 非unicode

        中文:
             str:
                表现形式: s = '中国'
                内部编码: unicode
            bytes:
                表现形式: b1 = b'\xe4\xb8\xad\xe5\x9b\xbd'
                内部编码: 非unicode

 

# s1 = '中国'
# b1 = s1.encode('gbk')
# print(b1)
# b2 = b1.decode('gbk').encode('utf-8')
# print(b2)
# s1 = 'zhong'
# b1 = s1.encode('utf-8')
# print(b1)
# print(b1.decode('gbk'))

 

------------->>>>>>>>>>>>>递归函数<<<<<<<<<<<<<<--------------------------

 

递归函数：在一个函数里在调用这个函数自己。

 

递归的最大深度：998

 

正如大家刚刚看到的，递归函数若是不受到外力的阻止会一直执行下去。可是咱们以前已经说过关于函数调用的问题，每一次函数调用都会产生一个属于它本身的名称空间，若是一直调用下去，就会形成名称空间占用太多内存的问题，因而python为了杜绝此类现象，强制的将递归层数控制在了997(只要997！你买不了吃亏，买不了上当...).

 

拿什么来证实这个“998理论”呢？这里咱们能够作一个实验：

def foo(n): print(n) n += 1 foo(n) foo(1)

由此咱们能够看出，未报错以前能看到的最大数字就是998.固然了，997是python为了咱们程序的内存优化所设定的一个默认值，咱们固然还能够经过一些手段去修改它：

 

 

import sys print(sys.setrecursionlimit(100000))

 

咱们能够经过这种方式来修改递归的最大深度，刚刚咱们将python容许的递归深度设置为了10w，至于实际能够达到的深度就取决于计算机的性能了。不过咱们仍是不推荐修改这个默认的递归深度，由于若是用997层递归都没有解决的问题要么是不适合使用递归来解决要么是你代码写的太烂了～～～

 

示例讲解------------->>>>>>>>>>>

 

例一：

 

如今大家问我，alex老师多大了？我说我不告诉你，但alex比 egon 大两岁。

 

你想知道alex多大，你是否是还得去问egon？egon说，我也不告诉你，但我比武sir大两岁。

 

你又问武sir，武sir也不告诉你，他说他比太白大两岁。

 

那你问太白，太白告诉你，他18了。

 

这个时候你是否是就知道了？alex多大？

 

递归实例:

def age(n): if n == 1: return 40
    else: return age(n-1)+2 print(age(4))

 

 

----------------------->>>>>>>>>>>>>>>>>>二分数查找<<<<<<<<<<<<<<<<<-----------------------------

 

若是有这样一个列表，让你从这个列表中找到66的位置，你要怎么作？

l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88]

你说，so easy！

l.index(66)...

咱们之因此用index方法能够找到，是由于python帮咱们实现了查找方法。若是，index方法不给你用了。。。你还能找到这个66么？

 

l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88] i = 0
for num in l: if num == 66: print(i) i+=1

上面这个方法就实现了从一个列表中找到66所在的位置了。

但咱们如今是怎么找到这个数的呀？是否是循环这个列表，一个一个的找的呀？假如咱们这个列表特别长，里面好好几十万个数，那咱们找一个数若是运气很差的话是否是要对比十几万次？这样效率过低了，咱们得想一个新办法。

 二分查找算法                  

l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88]

你观察这个列表，这是否是一个从小到大排序的有序列表呀？

若是这样，假如我要找的数比列表中间的数还大，是否是我直接在列表的后半边找就好了？

 

注意:列表必须是有序的,

         咱们知道2**16等于65536,也就是说,若是一个列表里有六万个数字,咱们用二分数查找,最多16次就可         以找到目标值.

 

 

这就是二分查找算法！

那么落实到代码上咱们应该怎么实现呢？ 

简单版二分法

l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88] def func(l,aim): mid = (len(l)-1)//2
    if l: if aim > l[mid]: func(l[mid+1:],aim) elif aim < l[mid]: func(l[:mid],aim) elif aim == l[mid]: print("bingo",mid) else: print('找不到') func(l,66) func(l,6)

升级版二分法

 

l1 = [1, 2, 4, 5, 7, 9] def two_search(l,aim,start=0,end=None): end = len(l)-1 if end is None else end mid_index = (end - start) // 2 + start
    if end >= start: if aim > l[mid_index]: return two_search(l,aim,start=mid_index+1,end=end) elif aim < l[mid_index]: return two_search(l,aim,start=start,end=mid_index-1) elif aim == l[mid_index]: return mid_index else: return '没有此值'
    else: return '没有此值' print(two_search(l1,9))

 

人理解函数,神理解递归!能够用下边的方法多跑几回程序,慢慢理解!!!