（五）Python----bytes，bytearray字节，字节序，（线性结构），切片

一. bytes,bytearray字节序列

Python3引入

bytes不可变字节序列

bytearray字节数组，可变列表

定义方式

1. bytes() 定义

encode（）编码，先当与定义bytes
decode（）解码
encoding=编码格式
errors=

2. b前缀定义
   只允许使用ASCII字符形式
   使用16进制表示

b3=bytes('abc','utf8')   #默认位UTF-8


b1=bytes()  
b2=b''


最优---给一个字符串编码----->字节序列
b3='abc'.encode()

b为bytes的前缀

ASCII 表

内存中的数据都是一个字符

\t --->\x09
\r --->13--->\x0d
\n --->10--->\x0a

\x30~~~~ \x39  字符0~~~~ 9

16进制   10进制      字符
\x41------>65-------->A
\x61------>97-------->a

这里的1指的是字符

二. bytes操作

1. 索引

返回的是该字节对应的10进制数

b=b'abcdefg'
print(b[2])

2. replace，find

和str相似，不可变
输入的是bytes，输出的也是bytes

例如：替换，查找

print(b'12341124'.replace(b'f',b'k'))
print(b'abc'.find(b'b'))

3. 类方法bytes.fromhex(string)

将16进制转为字符

string必须是2个字符的16进制形式，‘2134 23a 21b’ 空格将被忽略
bytes.fromhex(‘2314 23 4a 6b00’)

4. hex() 十六进制表达

将字符转为16进制

'abc'.encode().hex()

三. bytearray操作

支持，从一个字节序列或者一个buffer复制出一个新的对象

1. 初始化

bytearray(string,encoding[,errors])

不能用b当前缀

2. 索引

返回对应的十进制数

prrint(bytearray(b'abcd'[2]))  

a=bytearray(b'abcdefg')
print(a[2])
#99

3. replace，find

与bytes相似

b'abcdef'.replease(b'f',b'z')
b'ab',find(b'c')

4. 如何改变extend，append，pop

1. extend,后面为一个可迭代的整数集合
   bytearray支持，从一个字节序列或者一个buffer复制出一个新的对象
   a=bytearray(‘abcd’)
   b.bytearray(a)

2. append(int) 必须为元素（0~~255）为16进制的
   

3. pop()

a.pop()  默认山吹最后一个元素
a.pop(-2)  删除倒数第二个元素

弹出的类型为整形10进制

4. remove()
   必须用整形10进制数

fromhex（）

将16进制转为字符
生成的是bytearray，还可以追加

bytearray.fromhex('63 62 62')

hex()

将字符转为16进制

bytearray('abc'.encode().hex())

索引

bytearray(b'abcdef')[2]返回字符对应的10进制数

其他方法

四. 字节序（内存中）

内存中对于一个超过一个字节数据的分布方式

1. 大端模式，big-endian，
   网络传输更多使用大端模式，所以需要将小端模式转换为大端模式
   Mac OS使用打断模式
   Java续集及使用大端模式

2. 小端模式，little-endian，
   Intel X86 CPU使用小端模式
   Windows，linux使用小端模式，，所以需要将大端模式转换为小端模式

int和bytes转换

byteorder表示大端big，小端little

1. int.from_bytes(bytes,byteorder)
   按照指定字节序，将一个字节序列表示为-整数

大端模式

2. int.to_bytes(length,byteorder)
   按照指定字节序，将一个整数表示为-----一个指定长度的字节序列

五. 切片

线性结构

• 可迭代 for … in
• 有长度， 通过len(x) 获取，容器
• 可索引，通过整数下标 可以 访问元素，正索引，夫索引
• 可切片

如： list，tuple，str，bytes，bytearray

切片sequence

sequence[start:stop]
sequence[start:stop:step]

• 通过给定的索引区间获得线性结构的一部分数据
• start，stop，step为整数，可以是正整数，负整数，零
• start为0时，可以省略
• stop为末尾时，可以省略
• step为1时可以省略
• 切片是，索引超过上界（有边界），就取到末尾，超过下界（左边界），取到开头
• start一定要在stop的左边
• [:] 表示从头到尾，全部元素被取出，等效 于 copy()方法—浅拷贝

【:】前包后不包------> [ )

'abcdef'[:]

负数表示从后取

1. str字符串
   但start和stop顺序不能反，如下，最后一个
   
2. bytes字节
   step步长，和start，stop同向
   step跳过几个字节

（范围为1---4），取第一个1，和范围内的第2
print(b'abcdef'[1:4:2])
#bd

3. 切片赋值

切片操作 ，在等号左边
被插入的可迭代对象写在等号的右边

替换为一个可迭代对象
同时也可以删除------替换为空

练习

猴子吃桃

求杨辉三角形

逐行计算

n=6
#前两行
triangele=[[1],[1,1]]

for i in range(2,n):
    cul =[1]
    pre=triangele[i-1]
    for j in range(i-1):
        cul.append(pre[j+0]+pre[j+1])
    cul.append(1)
    triangele.append(cul)
print(triangele)

n=6
triangele=[]
for i in range(n):
    cul =[1]
    triangele.append(cul)  #申请地址（门牌号）
    if i ==0:
        continue
    pre=triangele[i-1]      #取出上一行的值
    for j in range(i-1):    #依次追上一行内容
        cul.append(pre[j+0]+pre[j+1])
    cul.append(1)
print(triangele)

两头补零：在每一行的左右补零

尾部补零（相当于，只给尾部追加一个0）
第一个1就是尾部的0+前面的1

n=10
#前两行
triangele=[[1],[1,1]]

for i in range(2,n):
    new =triangele[i-1]
    new.append(0)
    print(new)
    row=[None]*(i+1)
    for j in range(i+1):
        row[j]=new[j-1]+new[j]
    triangele.append(row)

如果是将每一行打印出来，就没有必要将所有的行都存起来

n=6
pre=[]
for i in range(n):
    cur=[1] #当前行
    if i !=0:
        for j in range(1,i):
            cur.append(pre[j-1]+pre[j])
        cur.append(1)
    print(cur)
    pre=cur

对称法
一次开辟空间，左右对称减少一半的计算

n=6
pre=[]
for i in range(n):
    cur=[1]*(i+1) #当前行
    for j in range(i//2):
        val=pre[j]+pre[j+1]
        cur[j+1]=val
        cur[-j-2]=val
    print(cur)
    pre=cur

排除重复覆盖的项

n=6
pre=[]
for i in range(n):
    cur=[1]*(i+1) #当前行
    #为 左边
    for j in range(1,i//2+1):
        val=pre[j-1]+pre[j]
        cur[j]=val
        #减少多余的赋值（覆盖性的）
        if i !=2*j:
            cur[-j-1]=val
    print(cur)
    pre=cur

如果 j 从零开始
得到终点的索引处i和j关系为i=2*(j+1)

n=7
tariangel=[[1],[1,1]]
for i in range(2,n):
    row=[1]*(i+1) #当前行
    #为 左边
    for j in range(i//2):
        var=tariangel[i-1][j]+tariangel[i-1][j+1]
        row[j+1]=var
        #减少多余的赋值（覆盖性的）
        if i !=2*(j+1):
            row[-j-2]=var
    tariangel.append(row)
print(tariangel)

单行覆盖
用单个列表，覆盖，切片(不能用负索引)

# 单列表，覆盖，切片完成
n=6
row=[1]*n  #依次性开辟
for i in range(n):
    old=1   #row[0]
    for j in range(i//2):
        val=old+row[j+1] # range(2) 0,1
        old=row[j+1]
        row[j+1]=val
        row[i-(j+1)]=val
    print(row[:i+1])

随机数字