2019/10/13 01-字典扁平化和base64编码实现

看到这一题，把一个字典扁平化，首先要知道考什么
可以用循环做，但是有的深有的浅，最好还是用递归，一般都是有深度的
递归不是没有效率，关键是你怎么写的，一般是牵扯到压栈弹出，所以效率低点

想到递归就先列个函数

递归套路，自己调用自己

要先遍历字典，一层层进去，和key和value都有关

不要无限递归，要记得有个边界条件，退出
一般判断v是边界，是字典就继续递归，否则该弹出
判断字典可以这么写，isinstance
是字典就自己调用自己，否则，else
（递归上来首先自己调用自己，然后要写退出条件，一般都是条件允许就递归，否则就一定要弹出了，弹出可以显式return，也可以隐式return=return none，函数执行完了也是return）
总是会出现不是字典的就需要和target有关了

需要个key=v，现在递归的架子已经出来了
target是全局的，最后改的都是同一个target，循环做完，最后return即可
有没有办法记住上次的key，把上次的称为前缀、

第一次拿到kv对，a是key，后面的是value
但是a丢了，所以需要想办法把a带上
想要a和b链接起来，a.b
前缀prefix = prefix + k+’.’ k是字符串，第一次拿的k就是a，v就是后面的字典
前面的前缀刚开始一定是空的
调用的时候，就需要加前缀，所以倒推到前面也需要加，可以给初始值，空字符串

等于‘’空字符+ k=a +’.’ =a.+{xxxx}
第二次带入进来，对后面的字典进行迭代，这时候prefix=‘a.’
第一个k=b v=1
这时候进行判断，这个v是不是字典（不是字典函数到头，没必要进去了）
就走到else：
问target怎么办，当前k=b 所以prefix+k =a.+b=a.b

迭代完之后 ，k=c，v=2
进不去判断是字典，因为v不是字典
就进入到else了
prefix+k =v 变成a.c =2

到了，d：xxx，开始
prefix=‘d.’
下面就是{‘e’:3,‘f’:{‘g’:4}}
perfix就是d.
d. 发现，3对应的就已经不是字典，
就变成d.e=3

主要是后面的f:{‘g’:4}；k=f，v=一个字典{‘g’:4}
进入到判断里
前面的prefix=d. k=f value={‘g’:4}
再调用一次函数，k=g v=4
prefix已经是d.f+k =v == d.f.g =4

一直在向前走，如果碰到字典就继续向前走，如果不是字典，就把target里面填充一下即可

不管递归多少层，最后return都是target，所有的层次，不管在哪个层次，return都是同一个地址引用
在函数中不断对target进行修改，target是在堆里面，创了一个字典，函数调用的时候压栈爱怎么压怎么压，操作字典还是一个
所有的函数不断调用多少层，return都是同一个target

跑一下试试，上面的src用的是局部变量，讲LEGB的时候，局部变量优先，外面的src影响不到里面去

只要知道操作的都是同一个target，如果里面还有字典，肯定够是有个前进阶段，当v不符合字典的时候就弹出，遇到字典就进入函数调用自己，再一次遍历，如果不是字典就需要对target做操作，该凑kv对了

递归的套路，首先写个函数，里面马上写自己调用自己 ，先把里面第一个参数确定，自己调用自己是无限的，所以就需要找退出条件
（字典特殊，因为每次传过来的值，kv拆开才能使用），退出条件某些时候要前进，某些时候要弹出
稍微要注意的就是返回值的问题

如果把最外层return去掉，内部就需要有个return，否则是return none，这是四层调用
自己调用自己压栈，你调用别人的函数也要压栈，这样第一层进来就不走下面分支

如果上面没有return，print是拿不到的

最外层走到里面第16行，return右边的，相当于一个函数返回值，如果没有返回值，下面print就拿到none

第二次进来判断走if还是else，如果走下面return nonne就不合适，应该returntarget
if里面的return也需要target
最外层函数要的就是target，通过这个tartget转给 外层print

就变成这种写法了

通过返回值的方法拿好，全局的不怎么好，因为函数是一种封装，传一个进去该给你return

但是有错误，a.b：1，说明是递归进去了
第一次进来prefix=’’，k=‘a’, v={‘b’:1,‘c’:2}
下面prefix拼接一下=prefix+k+‘.’=‘a.’
后面的v肯定是个字典 isinstance(v,(dict,))
进入递归 ret=flatmap(v,prefix) ({‘b’:1,‘c’:2}，prefix=a.) 要等待函数返回

表达式的右边先做，如果返回值没回来，这一行就卡住了

函数调用自己，第二次函数调用，prefix =a. ,k=b v=1
是1就不进去函数判断是否是字典
进入到else里：
prefix +k =v a.+b =1,
紧接着就return，就不会有a.c =2了，需要等到里面的循环结束，才return
需要写到循环外面去
上面两个属于同一种写法

还有一种写法，代表这里根本不需要返回值，
最外层return代表，不管你循环几次，每次就返回最外面的值，target，因为函数操作的target都是同一个，没有改变过

sorted，是把你要用的列表，放在自己内部构建，能否把target放到内部，但是这样只要函数调用一次，target就yoghurt的当前的，用的是新的局部变量的target，和上一次的target没有关系
但是target也可以放参数里来解决

也可以这么做】
target放到函数内部，但是现在缺一个函数调用

外面的src用外面的。里面的src用里面的，谁是谁的局部变量看的很清楚
这样调用就开始递归了，再内层函数做递归
计算好了target，return出去就完事了

构建的时候有几种方式，把target作为形参，一层层传进去，每一次都是局部变量，每调用一次局部变量跟上一次没有关系的，不用形参的方式带进去，是不行的

还有一种方式，学习了嵌套函数，让内层函数也可以递归

执行一下，这样也可以
带参和内层嵌套的函数都可以，但是上面的d.f.g出了点问题

调试一下看看


这一块有问题

prefix要放在用完后面的清理，放在函数调用后来清理是对的，库=可以

放在这个位置清理一下即可
内层函数依然是可以递归调用的

https://baike.baidu.com/item/base64/8545775?fr=aladdin
base64是最常见的传输8位字节码的方式之一，是用来传输用的，基于64个可打印的字符，表示没有空格，或者tab这类的看不到的字符，都是用的可见的字符，都是ascii码表里的可见字符，来表示二进制数据的方法，是由标准的

也就是首先得是二进制，二进制就是位，通用的方式是字节，就是把一个字节到字符 的过程，二进制的8位看作一个字符的过程，ascii码查询的时候也是这么做的，二进制的数，再计算机内部是无差别的，对于计算机，再内存中的数据都是二进制的，你说整型就是整型，字符串就是字符串，可以 把字符串映射成整型
如果是ascii码表，二进制这个数字01但是可以用10进制来理解，假如十进制是97，就要查表了，对应的刚好是小写字母a，内层中的一堆数据一个字节一个字节理解成ascii码，把8位当整型看，去查表即可
要想显示给你看，字符串要查字体相关的点阵打印出来
对于我们就相当于通过二进制来找到一个字符

base64又是一种编码，也是能从二进制找到一个字符，只编64个
只要数字0就对应A，ascii码是前0-127个作为编码
这里不是，只要是给一个数据，是0，就对应A，54对应2，ASCII码表里，50才对应字符2
一位可以表达2种状态，二位可以表达四种状态，三位，16，四位，16，五位32，六位64种状态，一个字节是8位

base64，64种状态就可以用，2的6次方，实际用6位就够 了，剩两位想办法，也不能全浪费掉，其实真的浪费掉了
对于序列，不关心原来是什么序列，对于base64来说，都是字节序列，其实python的所有数据类型都可以转换成二进制的列表
只不过告诉你从这个字节开始到下一个字节，就是你定义的一个序列，可以理解位一个字节组成的序列，一个挨一个，再python中，这个字节序列称为bytes
字符串怎么拿到bytes，一种是定义时加b（），还有就是 abc. encode，但是要告诉原来字符串转的编码是什么，因为python3默认使用unicode编码，utf-8

61 62 63,就是转换成10进制，
61=616^1 +116^0= 96+1=97
62=616^1+2*160= 96+2 =98
63=616^1+3*160= 96+3 =99

bytes表达，a占一个字节，b占一个字节，c占一个字节

用16进制表示就是616263

范围就是每8位一段，超出表示范围了，3 8正好24位 -》改成46 24位

现在是3个8位，24 位

改成4*6=24位

6位一段很安全，绝对不会超过0-63

（0110）2=80+41+21+10=（6）16
8421，前面的是
0110 00 = 01 1000 =10+8=18
01 0110 = 10+ 4+2 =16
0010 01 =00 1001 =8+1=9
10 0011 =20 + 3=23
把0x18 ,0x16,0x23,0x9看作八位的
0x18 = 00011000
0x16 = 00010110
0x 9 = 00001001
0x23 = 00100011
这就是38=24，变成46=24，

*先写一个3.8=24位，每6位每6位一段，断成4段
先把前面两个0去掉

凑在一起

改成3*8=24

移位运算是最快的
8//4=2
8 右移两次>>=2
8421
1000 》》2 =0010=2
0b1000 右移后面两个0直接丢弃可以不要 了

变成
0b1000 》》 0b10，前面的0都是无效的0，可以不写

如果只要前6个该怎么做，前面不动，后面全移掉即可，24位移3个6，右移18位即可

第二次右移多少，12位，从这开始后面0010 01100011都不要了

多了一些，就要做位于，用切的方式也能做，但是最不优雅
奇偶数的时候位与x=1

现在是拿整数在移，只要我们拿整数就行，数字可以右移，现在拿到的是一个bytes，如何拿到一个数字，int里就有方法

从3字节变成4字节 ，38=24，变成46=24，6当作完整字节看，占6位，取值范围就是从0-63，总共64种状态，这就是base64

写个编码表，3*8 24，假如给你一个字符，拿到的是一个字节，一个字节能转成6位
一个8前6个切除，后面两个送到第二个6里面去，第三个第四个没有，就补=等号
所以base64还有特殊东西就是等号

编码出来也是按字节出来的，src字符串
最后是要编码生成出来什么东西，就是你要解决的，要把目标算的不断加在一起
就需要一个字节序列 bytearray

假如字符串很长，先取三个字节，把这三个字节编码，再取三个字节编码，这个target目标是一直在追加的过程，又要用字节表达，能用的就只能是bytearray
（字节类型decode回到字符串）

src判断是否str，转换成字节encode（）（如果是字节转换成字节）
不符合else：
就返回

现在得到的_src就是已经被编码转换过的，就可以进行迭代的了，需要每次从_src拿三个字节，索引从0开始，
转成字节的长度才是我们要迭代的长度(len(_src)),步长是3
最后一次迭代的时候可能不能正常拿三个，也可能是正好拿0个，越界是没有问题的

要写余几个，假设是余0个，r=0，其实想知道的是，到底现在有几个
假设现在拿到的字符串就是’a’，想做base64编码
补两个等号
'ab’就是需要转成base64补一个等号

假设现在至于一个a， 97，转换成16进制 97/16 =61
97 =三个字节
97 01100001=61
01100001
011000 010000 000000 000000 这是base64的要求
1 2（一个6是装不下8位的，会延申到第二个6上去，要补两个==等号

ab要是断开，ab占了三个，
a = 97 16进制61
b=98 16进制 62
ab
01100001 01100010
4*6 =
011000 010110 0010 = 补一个等号
abc就不补，4。6=24，全部占满了

如果原来的余一个字符，就补两个等号，余两个补一个。余三个，不补

offset +3 就跟length有点关系，一开始offset是0，+3 就大于长度的问题
如果给的原字符串就是a，a是从0取到，取数0-3，超到右边去了，但是没关系，这个能取到的字符串（其实是bytes）
b’a’，当前offset刚好是0，如果0+3超过长度length，长度是1，就是从你当前+3没有下一次了，

可以试一下怎么来的
如果是’abc’，进去之后， 0：3，0到3取的就是b‘abc’，当前offset是0，0+3=3，当前的length就是3，3=3
就代表r=0，没必要进来了

第二种情况
‘ab’，在for循环了一次就迭代完了，因为步长是3，首先tripe先拿，拿出的就是ab，offset依然是0，0+3依然是3，长度是2，不进来
要知道未来补几个东西，在这顺带就算出来了

如果字符长度是6，0+3，就进不来，只有到最后一段的时候，才进来，
本身这段切片很简单，只切到右边界为止，切片好处就是可以超出边界，但实际达到边界就停下来了

下面只需要判断以后补几个

就用这种方式来总结补几个

先要拿到一个字节序列，拿出其中的三个字节，每6位断开，断成4断，每个字节其实只占了6位，就是 64位，
每一个6位又可以当8位看，也就是说看看6位能代表十进制几，这就是查表左边的字符的索引，由这个索引值对应什么字符

每六位加粗了
这是用十进制来表示

这是16进制，18转换成10进制是，16+8=24


一个字节呢个变成2个base64的字节，参考a
两个字节能变成三个base64字节，知道几个字节就知道补几个等号了


字符串反引号 ` 如何处理,是96
96转换成16进制，96/16=60
60转换成2进制
01100000

反引号·，01100000，当字节来理解就是这样的
转换成base64
01100000
4*6 =24
011000 00(这俩个0是有意义的，代表原有字节的0)00000 000000 000000
要补几个等号，应该是补两个等号
后面的0是人为添加的，（把4.6=24位凑齐，好算）
前面两个是原有字节的0

一个字符补完等号=，取几个字符
ab，前3个6都是我们从字节里拆出来的，后面补一个等号
这样我们出来时几个字符，加上等号是4个字符
、
**现在如果给你一个长字符串，改成base64编码，得到的字符因该是几的倍数，一定是4的倍数
3的字符按6位拆，得到4个字符，4个字符不够凑等号=，凑足4个字符，就是4的倍数
3字节每6位断开，变4字节就是，查表拿到4个字符，从三个字符变成4个字符，只不过后面的第四个字符是安全可见字符，
**

base留下的都是安全的字符，它是从ascii码中挑选了一些可见的安全的不冲突的字符

现在要做一件事情，
取的时候有可能取到一个不够长度的，凑不够24位，怎么移位，一个字符拆成8位，怎么移18位，这个8位应该放在最左端，后面怎么移就需要补0

*现在就看后面怎么补0，如果现在的长度缺两个 r=2，说明ascii是一个字符，缺两个字符，就拼过来，拼过来的目的就是变成3，
如果现在取的是an，这个r就是1，拼一个单字节进去b’ 'r 凑够三个字节，从3 变成4

src如果是a，，不够三个，就需要补两个单字节

如果是ab，长度是2，3-2=1，就需要补一个字节，凑够3个字符
这样3*8=24位就有了，下面就可以移位计算，每六位六位提取出来就可以

abc就正好是三个，进不去，不用凑字节

如果原子符，a bc有空格，你凑的也是空格，那就不好处理，但是原子符串最好不要加特殊字符，但是有特殊字符就是
ascii码0，不是数字0，而是ascii码0，
因为写其他字符都有可能干扰，这个就比较特殊，这个不属于原字符串，是为了计算方便
ascii码就是null，转义需要\0,在内存中8位全是0
数字0的ascii码是32

0x代表定义数字（16进制描述数字，\x代表字符串（是16进制的字符表达方式

写的是ascii对应的0，在内存中是0,就是补的下面的这些，因为写其他字符都有可能干扰，这个就比较特殊，这个不属于原字符串，是为了计算方便
3变4只需要记住，从-1开始（尾巴）替换几个，替换一个把-1替换掉就行，2个就是把-1-2替换


base64在网络中用途极广

到这一步就能完成每三个三个字节一取，如果取的不是三个字节，就帮你补齐三个字节，而且补了几个都记住，
补ascii码0最合适，内存中表现的方式就是00000000 8位0
ascii码0和数字0是两码事，ascii码0非常特殊是null

紧接着要怎么处理，就需要每6位6位一断，可以6位6位取也没有问题，移位计算把4*6=24的最高的6位留下来，第一次向右移6位

上面是从3到4，一定可以拿到24位，因为已经补齐了，

第一把，把tripe拿到手，需要向右移i位，得到的就是index，拿到的字节向右推了18位

**看这个a，补等号（0）是以后的事情
a后面补了2个0 ，后面全部都补上 了
01100001 00000000 00000000
011000 010000 000000 000000 **

如果现在给的字符串就是单个字符，6位一段，相当于右边移18位就可以了，得到的东西就称为index，
01 1000 =18 10进制就是24 18=1*16^1+8=24

到base64查一下就是24 =y了
这是第一次，第二个过来，第二次-6就是12，12就剩下这么多

一个是高处的6位，一个是低的6位
011000 010000

就可以做位与，位与可以当按位的乘法
011000 010000
000000 111111 &
0x 3 f
后面4位加1就进位了，全满就是f ，8421，就是15

如果只移6位，就剩下这么多，前面是什么依然不关心，关心的还是最低6位

如果拿出这样的，与几相与，依然是3F，前面是什么不关心，关心的还是最低的6位

也可以这么描述，但是这样没有意义

第一次拿到的只有6位，第一次24位，挪18位，剩6位，剩六位跟6位相与也可以，移位是按照数据来移位的
现在是字节，数字才可以移位，所以中间缺了一步，从bytes到int，然后int再移位

事实上这是一个个字节，整数才能移位，所以需要bytes转成int

18，12，6，还少一次，0也需要，写个比0小的-1即可

18的时候就不用做位与了

**还剩一个转int的问题
val转完是个10进制的，默认表示方式是10进制的，所以在移位的时候就搞不清楚了，所以刚才就省略讲了中间转换过程,但是执行省略就一定出错 **

思路：
首先拿到一个序列，转成bytes

转成bytes之后就可以对它一个字节一个字节的处理，但是我们一次拿3字节，因为我们要把3字节变成4字节，
如何从3 变4
38=24 46=24，每6位一段，每6位得到单独的数就是我们要的，相当于把6位前面2位补0，也就是这移位得到的数据就是你想要的数据，前面没有补8位就是补0

就是从这步到这步
下面是6位。就补两个0，虽然是6位，4*6=24
但是实际用的时候可以当8位看，每个8位转换成10进制
1000是二进制，转换成10进制就是8，就是脑补前面补4个0、
习惯写成0x8，跟8一个道理

24转换成2进制
24/16 =15
标准库里，效率比较高会用位运算

用位运算的好处就是效率比较高，不用位运算，python是会给你优化，比如像java中的
i= i+1
i +=1
i++
通常问哪种效率高，这三种其实是一样的，解释器，在编译你代码的时候会做优化

现在做的就是补齐，
补齐之后转成int，转int的就是为了移位得出4位里面的每一个数，由这个数，现在已经拿到了index

拿到了index，这个target就可以追加东西进去了

**bytearray可以用append的方法，bytes是不可变的，bytearray是可变的，相当于列表和序列
**现在把index追加进去即可，还有做的就是查表。alphabet[index]，等于算出的index，去到编码表里去找，找到之后相当于得到一个字符，这个字符相当于bytes，把bytes追加到target

用+=也可以，+=是对于可变类型来讲，相当于是就地修改，不可变类型就是产生一个新的把自己覆盖掉

到目前位置base64的核心代码写的差不多了，但是遇到这些问题，怎么办，其实就是最后面多出一个二个问题，如果是这样子还不如先补齐再计算，因为如果是一个字节，多出2位要放在后面的6位前2位上去，后面的4个0怎么来的，最后还得补0，与其补0还不是凑够3个字节，反正后面全补0，不够再说，补完之后再替换掉，到目前为止，应该是差不多可以了·

假如要调自己写的东西，src这里要的是字符串，送个’a’进去，如果传入东西正好是bytes，就算了不要动了，总之得拿到一个bytes然后用bytes进行下面的计算

这里的长度一定是bytes，不是字符串
拿到bytes，就每三位三位取，这就是循环内部，一次拿三个，
如果不够三个就补，补几个在这里处理好即可，补好之后，这是一个字节型的，是一个字节序列，能否把一个字节序列转成整数，证书才可以移位

这是int里面就有from_bytes，转一下，一般都是用大头’big’

得到的值想办法移位，移位有时候前面剩一点，如果不要，就都用位与的方式把它去掉

如何位与，就把你想要的位-1，不想要的位写0，凑出来的数字你看是几，想要的是后面6位全部标1，把这个数子转换成16进制就是 3 F ，3f就是6个1 111111，2进制的6个1，先移位后与，就等于把你想要的卡出来，其他不要的都覆盖掉，0x3f就是一个框，一长串数字只想要一段，就框住

假如现在有一个二进制数，01011010000，只想要最后一个字节的高四位，其他的都不关心，最简单的还是做位与计算
010 11010000
000 11110000 &
0000 11010000结果
与完之后剩下高四位，把这后右移4位去掉即可

如果要最后一个字节的第几位，最后几个字节你见着要就这么要，一般没这个需求

位与相当于按位相乘，位或，按位相加，

后面加个return就差不多了

与系统库做下对照，差在这个等等==上了，
A是最低留的两位01，01是放到第二个6位上

这个转换就正好是16进制10
0010 0000

后面的0刚好对于编码表的A

所以现在得到的是YQAA，但是这两个AA是不能做数的


如果想要bytearray转换成bytes

如果想要输出一样，就做一下替换，有几个替换几个，倒着替换即可
r=2就是1，3 替换2个
r=1就是1，2 替换一个
提示需要整数

=号 ASCII码
整数就是61

所以这里直接给成61即可，因为当一个字节来看，是当整数来看的（而多个字节就牵扯到字符串了，就有编码的问题了）

现在补充一种语法
r=2
右边是给一个序列，这个序列有两个元素，相当于两个等号对应的bytes
左边代表从-2到结尾，两个空
意思就是从-2到结尾的两个空，用后面两个来填充
（从几到几，使用什么方式来填充）

从-2开始到往后来

从倒数第二开始，向后整个替换这个

因为告诉的是从-3到结尾使用后面的序列填充

-3到-2的区间刚好是c这个格子

为什么让bytearray，list少用，因为这是典型的插队，这种操作能少做则少做

其实经过测试下面效率稍高，因为还没有引起插队
（如果引起插队，等于做insert，同时兼具覆盖，对于大的序列来讲，就要思考这个操作是否合理了 ）

表示从头到尾都替换
这里直接覆盖还行，尤其遇到插队效率就比较低

’a’余一个，ab，余两个，abc正好够的，·反引号特殊的东西，一个中文utf-8是三个字节，3字节+1字节+3字节

打印字符串，并且间隔一下
加个断点

**abc出了点小问题
**
src是bytes的abc

length=3，offset0，tripe拿的是3 0+3 》不大于length

现在拿到val=abc 从bytes转成int整型得到


看这个值不方便可以，修改一下
转换成hex，就是16进制，616263

val，得到的大整数就是6362179，转换层16进制就是616263

现在开始移位，如果等于18直接移位，24

再移

j

补一下

这里其实需要加判断，r！=0的时候才补

因为这个r是你写的局部变量，由你说了算，要么等于0，要么等于你剪出来的值

现在就一模一样了

中文的时候默认encode是编码utf-8的，大多数中文都占3个字节
utf-8是变长的，在英文部分保持ascii兼容，0-127是一模一样的
对中文的编码是由unicode转过来的，utf-8，这种编码方式大多数是3个字节
都是要补0的

base64在编码后，算总长度的时候，是4个倍数，就知道都是由3字节凑出来的，多出来的部分换成等号即可，通过规律发现，要么补一个等号，要么补两个，绝对不会超过2个

在有些时候base64编码到最后没有等号，用base64解码的时候，未必成功，因为故意把等号省略了，但是我们要处理的时候（如何知道是把等号扔掉的），看一下倍数r
移位的技巧看明白

base64不能直接移位，需要转换成整数来移位，
为什么bytes和int能看成整数，内存都是0和1 组成的，这个字节看做整数还是字符串，都是你强加给它的，说到底现在就暂时先看成整数

这边一般都是替换

可以del，相当于从这个列表，把移不开可变的一部分剔除掉，从一个队伍把几个人拿出来，这个队伍是要进行挪动的，应该少做
、
序列好处就是使用索引，坏处就是发生变化就需要整体移动，追加在尾部还行