bytes_byte数组 - CSDN
精华内容
参与话题
  • bytes数据类型

    千次阅读 2019-02-26 19:21:23
    文本总是Unicode,由str类型表示,二进制数据则由bytes类型表示。Python3不会以任意隐式的方式混用str和bytes,正是这使得两者的区分特别清晰。你不能拼接字符串和字节包,也无法在字节包里搜索字符串(反之亦然),也...

    Python3最重要的新特性大概要算是对文本和二进制数据作了更为清晰的区别。文本总是Unicode,由str类型表示,二进制数据则由bytes类型表示。Python3不会以任意隐式的方式混用str和bytes,正是这使得两者的区分特别清晰。你不能拼接字符串和字节包,也无法在字节包里搜索字符串(反之亦然),也不能将字符串传入参数为字节包的函数(反之亦然)。这是件好事。

     

    字符串是以字符为单位进行处理的,bytes类型是以字节为单位处理的。

    bytes数据类型在所有的操作和使用甚至内置方法上和字符串数据类型基本一样,也是不可变的序列对象。

    bytes对象只负责以二进制字节序列的形式记录所需记录的对象,至于该对象到底表示什么(比如到底是什么字符)则由相应的编码格式解码所决定。Python3中,bytes通常用于网络数据传输、二进制图片和文件的保存等等。可以通过调用bytes()生成bytes实例,其值形式为 b'xxxxx',其中 'xxxxx' 为一至多个转义的十六进制字符串(单个 x 的形式为:\x12,其中\x为小写的十六进制转义字符,12为二位十六进制数)组成的序列,每个十六进制数代表一个字节(八位二进制数,取值范围0-255),对于同一个字符串如果采用不同的编码方式生成bytes对象,就会形成不同的值.

     

     

    不管怎样,字符串和字节包之间的界线是必然的的,下面的图解非常重要,务必要牢记于心:

     

    b = b'' # 创建一个空的bytes
    b = byte() # 创建一个空的bytes
    b = b'hello' # 直接指定这个hello是bytes类型
    b = bytes('string',encoding='编码类型') #利用内置bytes方法,将字符串转换为指定编码的bytes
    b = str.encode('编码类型') # 利用字符串的encode方法编码成bytes,默认为utf-8类型

    bytes.decode('编码类型'):将bytes对象解码成字符串,默认使用utf-8进行解码。

     

    对于bytes,我们只要知道在Python3中某些场合下强制使用,以及它和字符串类型之间的互相转换,其它的基本照抄字符串。

    简单的省事模式:

    string = b'xxxxxx'.decode() 直接以默认的utf-8编码解码bytes成string

    b = string.encode() 直接以默认的utf-8编码string为bytes

     

    计算机内存地址和为什么用16进制?

    为什么用16进制

    1、计算机硬件是0101二进制的,16进制刚好是2的倍数,更容易表达一个命令或者数据。十六进制更简短,因为换算的时候一位16进制数可以顶4位2进制数,也就是一个字节(8位进制可以用两个16进制表示)

    2、最早规定ASCII字符集采用的就是8bit(后期扩展了,但是基础单位还是8bit),8bit用2个16进制直接就能表达出来,不管阅读还是存储都比其他进制要方便
    3、计算机中CPU运算也是遵照ASCII字符集,以16、32、64的这样的方式在发展,因此数据交换的时候16进制也显得更好
    4、为了统一规范,CPU、内存、硬盘我们看到都是采用的16进制计算


    16进制用在哪里
    1、网络编程,数据交换的时候需要对字节进行解析都是一个byte一个byte的处理,1个byte可以用0xFF两个16进制来表达。通过网络抓包,可以看到数据是通过16进制传输的。
    2、数据存储,存储到硬件中是0101的方式,存储到系统中的表达方式都是byte方式

    3、一些常用值的定义,比如:我们经常用到的html中color表达,就是用的16进制方式,4个16进制位可以表达好几百万的颜色信息。

     

    展开全文
  • bytes是什么 由上篇文章几种字符编码, 我们已经知道了ASCII Unicode UTF-8的关系。而且,计算机只能识别0和1,那显然,文件存储在计算机中也只能是以二进制的形式存储,字符编码在计算机中的工作机制是怎样的呢? ...

    bytes是什么

    由上篇文章几种字符编码, 我们已经知道了ASCII Unicode UTF-8的关系。而且,计算机只能识别0和1,那显然,文件存储在计算机中也只能是以二进制的形式存储,字符编码在计算机中的工作机制是怎样的呢?

    在计算机内存中(你打开电脑上的一个文件是要从硬盘读取到内存中的),统一使用Unicode编码。在需要保存到硬盘或需要传输时,就转化为UTF-8编码(由上篇文章可知,这样可以节省空间,提高传输速度)。

    如,在记事本编辑时,从文件读取的UTF-8字符被转化为Unicode字符到内存里,编辑完成,保存时在将内存中的Unicode字符转化为UTF-8保存到文件:

    mark

    浏览网页时,服务器会把动态生成的Unicode字符转化为UTF-8字符再传输到浏览器:

    mark

    所以你看到很多网页的源码上会有类似<meta charset="UTF-8" />的信息,表示该网页正在使用UTF-8编码。

    在python中,字符串是以Unicode编码的,而python的字符串类型是str,内存中以Unicode表示。要在网络上进行传输或保存到磁盘中,就需要将str转化为以字节为单位的bytes

    要获取字符的bytes表示,可以使用encode()方法,如

     

    >>> 'ABC'.encode('ascii')
    b'ABC'
    >>>'ABC'.encode('utf-8')
    b'ABC'
    >>> '中文'.encode('utf-8')
    b'\xe4\xb8\xad\xe6\x96\x87'
    >>> '中文'.encode('ascii')
    Traceback (most recent call last):
      File "<input>", line 1, in <module>
    UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)
    

    纯英文的str,可以用ascii编码为bytes,其内容与utf-8相同。含中文的str不能用ascii编码为bytes,其超过了ascii编码的范围,会报错。

    bytes中,无法显示为ASCII字符的字节,会以b\x##的形式显示。

    使用type可以查看b'abc'或b'\xe4\xb8\xad\xe6\x96\x87'的数据类型,是一个bytes类

     

    >>> type(b'\xe4\xb8\xad\xe6\x96\x87')
    <class 'bytes'>
    

    相反,从网络上或磁盘中读取到了字节流,读到的就是bytes,需要用decode()方法解码为str

     

    >>> b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')
    '中文'
    
    

    字节字符串与文本字符串

    b'ABC' 与 'ABC'是不同的,前者是bytes,也叫字节字符串;后者是str,也称为文本字符串。前者一个字符占一个字节(中文一个汉字占三个字节),str类型在内存中以Unicode表示,一个字符占若干字节。

     

    >>> len('下'.encode('utf-8'))
    3
    

    在读取二进制数据的时候,字节字符串和文本字符串可能会引起错误。特别需要注意的是,索引和迭代动作返回的是字节的值而不是字节字符串。

     

    >>> # Text string
    >>> t = 'Hello world'
    >>> for x in t:
    ...     print(x)
    ...     
    H
    e
    l
    l
    o
    w
    o
    r
    l
    d
    >>> # Byte string
    >>> b = b'Hello world'
    >>> for x in b:
    ...     print(x)
    ...     
    72
    101
    108
    108
    111
    32
    119
    111
    114
    108
    100
    

    Base64:显示与打印二进制数据

    Base64是一种用64个字符表示任意二进制数据的方法。

    当我们用记事本打开bmp, exe, jpg文件时,会出现一大堆乱码:

    mark

    这是因为它们不是文本文件,是二进制文件,而二进制文件包含很多无法显示和打印的字符,所以,如果想让记事本这样的文本处理软件能处理二进制数据,就需要一个二进制到字符的转换方法,Base64是一种最常见的二进制编码方法。

    注意:通常我们说编码都是将字符编码成二进制,将二进制解码为字符。而现在我们说的是将二进制编码为字符文本,将字符文本解码为二进制。不要弄混,笔者在最开始学的时候全程懵逼,完全搞不明白到底是在解码还是编码。

    方法:

    准备一个包含64个字符的数组:

    ['A', 'B', 'C', ... 'a', 'b', 'c', ... '0', '1', ... '+', '/']

    对二进制数据进行处理,每三个字节一组,共3 * 8 = 24bit,划为4组,每组6个bit:

    mark

    我们得到四个数字作为索引,查表,得到对应的4个字符,就是编码后的字符串。

    所以,我们是将3个字节的二进制数据编码为4个字节的文本数据,长度增加33%,好处是编码后的文本可以在邮件正文、网页中正常显示。

    python内置的base64模块可以提供base64的编解码功能:

     

    >>> import base64
    >>> base64.b64encode(b'i\xb7\x1d\xfb\xef\xff')
    b'abcd++//'
    >>> base64.b64decode(b'abcd++//')
    b'i\xb7\x1d\xfb\xef\xff'
    

    当要编码的二进制数据不是3的倍数,最后会剩下1或2个字符时怎么办?Base64会自动在末尾用b\x00补足后在进行解码,再在编码的结尾加上1或2个=,以表示在二进制数据末尾加了几个b\x00

    但是,在很多Base64编码中会把=去掉,因为它会在URL,Cookies中造成歧义:

     

    # 标准Base64:
    'abcd' -> 'YWJjZA=='
    # 自动去掉=:
    'abcd' -> 'YWJjZA'
    

    去掉=怎么解码呢,因为Base64编码后的长度永远是4的整数倍,所以将不是4的整数倍的Base编码自动添加相应数量=后使其变为4的整数倍后再解码即可

    你可能会想,上面我们已经说了可以用decode解码二进制数据,为什么现在还需要对二进制数据编码再显示呢?

    原因是:上文针对的是文本文件中的字符,而像jpg bmp mp3等二进制格式文件,其中的二进制数据不能正常解析为字符:

     

    >>> '中文'.encode('utf-8')
    b'\xe4\xb8\xad\xe6\x96\x87'
    >>> b'\xe4\xb8\xad\xe6\x96\x56\x87'.decode('utf-8')
    Traceback (most recent call last):
      File "<input>", line 1, in <module>
    UnicodeDecodeError: 'utf-8' codec can't decode bytes in position 3-4: invalid continuation byte
    

    可很多时候我们会在一些文件头加一些与文件属性有关的数据,如在jpg文件头加数据表示该图片的大小、分辨率、色彩等信息,这时我们就需要通过对二进制进行编码读取这些信息了。

    struct bytes与其他数据类型的转换

    Bytes之间可以进行加法(无减法操作)组成一个新的bytes:

     

    >>> m = b'hello '
    >>> b = b'world'
    >>> m+b
    b'hello world'
    >>> m+b'world'
    b'hello world'
    

    根据前文已知,将字符转换成二进制可以使用encode()方法,那如果是非字符型数据如整数、浮点数怎么转换成二进制数据呢?

    Python提供了一个struct模块来解决bytes与其他数据类型之间的转换:

     

    >>> struct.pack('>I', 10240099)
    b'\x00\x9c@c'
    

    pack第一个参数是处理指令,'>I'的意思是:

    >表示字节顺序是big-endian,也就是网络序,I表示4字节无符号整数,unsigned int

    后面参数个数要与处理指令一致,大小也要在指定的参数范围内:

     

    >>> struct.pack('>2H', 10245599)
    Traceback (most recent call last):
      File "<input>", line 1, in <module>
    struct.error: pack expected 2 items for packing (got 1)
    
    >>> struct.pack('>2H', 102456565599)
    Traceback (most recent call last):
      File "<input>", line 1, in <module>
    struct.error: pack expected 2 items for packing (got 1)
    

    H表示整数,两字节无符号整数,usigned short

    struct模块定义的数据类型可以参考python的官方文档

    mark

    相反,unpack指令就用来将字节流bytes按给定参数转化为我们想要的格式:

     

    >>> struct.unpack('>I', b'\x00\x9c@c')
    (10240099,)
    

    该句指令的意思是:将给定的字节流转换成unsigned int类型的4字节无符号整数。unpack同样也可以将字节流转换为字符数据,更换参数即可。

    unpack返回的是tuple类型

    应用场景

    有时需要用python处理二进制数据,比如存取文件,socket操作时。这时可以用python的struct模块来完成,比如可以用struct处理c语言中的结构体。

    比如有一个结构体:

     

    struct Header
    {
        unsigned short id;
        char[4] tag;
        unsigned int version;
        unsigned int count;
    }
    

    通过socket.recv接收到了上面的结构体数据,存在字符串s中,bytes格式,现在把它解析出来,可以使用unpack函数:

     

    import struct
    id, tag, version, count = struct.unpack('!H4s2I', s)
    

    !表示网络字节顺序,因为数据是从网络上接收到的,再网络上传送时他是网络字节顺序的。后面的H4s2I表示1个unsigned int4s表示4字节的字符串,2个unsigned short

    通过一个unpack就将id, tag, version, count数据解析好了。

    同样,也可以使用pack再将本地数据pack成struct格式

    ss = struct.pack('>I4s2I', id, tag, version, count)

    pack函数按照指定格式转换成了结构体Header,ss现在是一个字节流,可以通过socket将这个字节流发送出去

     

    展开全文
  • 字节bytes的操作大全

    2019-03-11 18:04:14
    本节要讲的内容将是一个重点内容 1.字节切片比较 2.字节切片判断 3.字节切片是否包含另外切片的值 4.字节切片是否包含相同UTF-8的字符 5.字符切片是否包含相同的 Unicode编码字符 6.字符切片a中包含多少组不重复的...
        

    本节要讲的内容将是一个重点内容

    • 1.字节切片比较
    • 2.字节切片判断
    • 3.字节切片是否包含另外切片的值
    • 4.字节切片是否包含相同UTF-8的字符
    • 5.字符切片是否包含相同的 Unicode编码字符
    • 6.字符切片a中包含多少组不重复的Unicode编码切片b
    • 7.将切片按照空格分割成多个子切片
    • 8.将切片按照指定的规则分割成多个子切片
    • 9.字节切片是否包含前缀字符切片
    • 10.字节切片是否包含后缀切片
    • 11.获取第一个子切片所在的位置index
    • 12.获取切片b中任意一个Unicode编码字符第一次出现在切片a中的位置
    • 13.获取字符b 第一次出现在切片a中的位置
    • 14.返回第一个满足规则的unicode编码字符b,在切片a中的位置
    • 15.返回uncode编码第一次出现在切片a中的位置
    • 16.将多个切片通过字符连接成一个大的切片
    • 17.返回切片b最后一次出现在切片a的索引
    • 18.返回字符切片b中任意字符,最后一次出现在切片a中的位置
    • 19.返回字符b最后一次出现在切片a中的位置
    • 20.返回指定规则下,返回字符最后出现在切片a中的位置
    • 21.map方法处理数组数据
    • 22.将字符切片,重复n此组成新的切片
    • 23.用新的切片,替换切片a中的子切片的数据
    • 24.将utf-8的字符切片转换为rune切片
    • 25.将切片按照字符切片b分割成多个子切片数组,不包含切片b
    • 26.将切片按照字符切片b分割成多个子切片数组,包含切片b
    • 27.将切片按照字符切片b分割成n个子切片数组,如果数量达到n则不在继续分割
    • 28.切片字符中,按照空格划分成字符串,首字符设置大写
    • 29.切片全部转换为小写
    • 30.切片全部转换为小写
    • 31.从左边开始切割字符切片s中出现的字符切片b,返回剩余的数据
    • 32.从右边开始切割字符切片s中出现的字符切片b,返回剩余的数据

    1.字节切片比较

    package main
    
    import (
      "bytes"
      "fmt"
    )
    
    func main() {
      var a,b []byte
      a = []byte{'b','a'}
      b = []byte{'c'}
      fmt.Println(bytes.Compare(a,b))
    
    }
    
    1594482-622e36cba72d0d8d
    image.png

    两个切片,从下标0的位置,以此进行比较,如果值相等,则进行后面的值比较,直到数据不相等,如果值a > 值b 则返回 1, a == b 返回 0,否则返回-1


    2.字节切片判断

    package main
    
    import (
      "bytes"
      "fmt"
    )
    
    func main() {
      var a,b []byte
      a = []byte{'b','a'}
      b = []byte{'c'}
      fmt.Println(bytes.Equal(a,b))
    }
    

    判断规则和上面一致

    1594482-f31e01f67e978975
    image.png

    3.字节切片是否包含另外切片的值

    func Contains(b, subslice []byte) bool

    package main
    
    import (
      "bytes"
      "fmt"
    )
    
    func main() {
      var a,b []byte
      a = []byte{'b','a','c'}
      b = []byte{'c'}
      fmt.Println(bytes.Contains(a,b))
    }
    
    1594482-fa4822836e2f7042
    image.png

    4.字节切片是否包含相同UTF-8的字符

    func ContainsAny(b []byte, chars string) bool

    package main
    
    import (
      "bytes"
      "fmt"
    )
    
    func main() {
      var a []byte
      a = []byte{'b','a','c'}
    
      fmt.Println(bytes.ContainsAny(a,"abcde"))
    }
    

    检测规则如下

    ContainsAny 检测chars的任何 UTF-8 编码的 Unicode 代码点是否在 b 中。

    5.字符切片是否包含相同的 Unicode编码字符

    package main
    
    import (
      "bytes"
      "fmt"
    )
    
    func main() {
      var a []byte
      a = []byte("我爱你")
      var c rune = '我'
      fmt.Println(bytes.ContainsRune(a,c))
    }
    
    1594482-bb82783be4914525
    image.png

    6.字符切片a中包含多少组不重复的Unicode编码切片b

    package main
    
    import (
      "bytes"
      "fmt"
    )
    
    func main() {
      var a,b []byte
      a = []byte("我我我爱你")
      b = []byte("我")
      fmt.Println(bytes.Count(a,b))
    }
    
    1594482-253cb337792439b4
    image.png

    如何 b为空 怎么返回 len(a) + 1 ,即 6

    如下

    package main
    
    import (
      "bytes"
      "fmt"
    )
    
    func main() {
      var a,b []byte
      a = []byte("我我我爱你")
      b = []byte("")
      fmt.Println(bytes.Count(a,b))
    }
    
    1594482-32dc47b051388a17
    image.png

    7.不区分大小写 比较两个切片的大小

    package main
    
    import (
      "bytes"
      "fmt"
    )
    
    func main() {
      var a,b []byte
      a = []byte("a")
      b = []byte("A")
      fmt.Println(bytes.EqualFold(a,b))
    }
    
    1594482-bec91c91d87ed06f
    image.png

    7.将切片按照空格分割成多个子切片

    package main
    
    import (
      "bytes"
      "fmt"
    )
    
    func main() {
      var a = []byte("ab  c d")
      var list [][]byte
      list = bytes.Fields(a)
      fmt.Println(list)
    }
    
    1594482-1da2ab0bf0aea08f
    image.png

    8.将切片按照指定的规则分割成多个子切片

    package main
    
    import (
      "bytes"
      "fmt"
    )
    
    func main() {
      var a = []byte("a=b&c=d&f==e")
      var list [][]byte
      var f = func (s rune) bool{
        if(s=='&'){
          return true
        }
        return false
      }
      list = bytes.FieldsFunc(a,f)
      fmt.Printf("count:%d,%q",len(list),list)
    }
    
    1594482-20d78777450e0b7f
    image.png

    9.字节切片是否包含前缀字符切片

    package main
    
    import (
      "bytes"
      "fmt"
    )
    
    func main() {
      var a = []byte("xj-abcdef")
      var b = []byte("xj")
      fmt.Println(bytes.HasPrefix(a,b))
    }
    
    1594482-528c68fa8ce3be2e
    image.png

    字符切片是否包含后缀切片

    package main
    
    import (
      "bytes"
      "fmt"
    )
    
    func main() {
      var a = []byte("xj-abcdef")
      var b = []byte("ef")
      fmt.Println(bytes.HasSuffix(a,b))
    }
    
    1594482-2500f8e069aeb1a4
    image.png

    11.获取第一个子切片所在的位置index

    package main
    
    import (
      "bytes"
      "fmt"
    )
    
    func main() {
      var a = []byte("xj-abcdef")
      var b = []byte("ef")
      fmt.Println(bytes.Index(a,b))
    }
    
    1594482-202a0af34d98a670
    image.png

    12.获取切片b中任意一个Unicode编码字符第一次出现在切片a中的位置

    package main
    
    import (
      "bytes"
      "fmt"
    )
    
    func main() {
      var a = []byte("xj-我abcdef")
      var b = "efghe"
      fmt.Println(bytes.IndexAny(a,b))
    }
    
    1594482-00c2b0b66230d0e8
    image.png

    13.获取字符b 第一次出现在切片a中的位置

    package main
    
    import (
      "bytes"
      "fmt"
    )
    
    func main() {
      var a = []byte("xj-我abcdef")
      var b = byte('e')
      fmt.Println(bytes.IndexByte(a,b))
    }
    
    1594482-ccd0d0c9f1b64c8c
    image.png

    返回第一个满足规则的unicode编码字符b,在切片a中的位置

    package main

    import (
    "bytes"
    "fmt"
    )

    func main() {
    var a = []byte("xj-我爱abcdef")
    var f = func(r rune)bool{
    return r > rune('我')
    }
    fmt.Println(bytes.IndexFunc(a,f))
    }

    1594482-ca56f61c1de938ea
    image.png

    15.返回uncode编码第一次出现在切片a中的位置

    package main
    
    import (
      "bytes"
      "fmt"
    )
    
    func main() {
      var a = []byte("xj-我爱abcdef")
      var f = rune('我')
      fmt.Println(bytes.IndexRune(a,f))
    }
    
    1594482-50320d711af19b1c
    image.png

    16.将多个切片通过字符连接成一个大的切片

    package main
    
    import (
      "bytes"
      "fmt"
    )
    
    func main() {
      var a = []byte("xj")
      var b = []byte("-abc")
      var s = bytes.Join([][]byte{a,b},[]byte("&"))
      fmt.Printf("%q",s)
    }
    
    1594482-a3554838840dce63
    image.png

    17.返回切片b最后一次出现在切片a的索引

    package main
    
    import (
      "bytes"
      "fmt"
    )
    
    func main() {
      var a = []byte("xj")
      var b = []byte("-abc")
      var lastIndex = bytes.LastIndex(a,b)
      fmt.Println(lastIndex)
    }
    

    未找到则返回-1


    1594482-28ab9ad73a84e468
    image.png

    18.返回字符切片b中任意字符,最后一次出现在切片a中的位置

    package main
    import (
      "bytes"
      "fmt"
    )
    func main() {
      var a = []byte("xjaaaa")
      var b = "bcdefa"
      var lastIndex = bytes.LastIndexAny(a,b)
      fmt.Println(lastIndex)
    }
    
    1594482-a00858dc6c035603
    image.png

    19.返回字符b最后一次出现在切片a中的位置

    package main
    
    import (
      "bytes"
      "fmt"
    )
    
    func main() {
      var a = []byte("xjaaaa")
      var b = byte('a')
      var lastIndex = bytes.LastIndexByte(a,b)
      fmt.Println(lastIndex)
    }
    

    1594482-48aa437002d8a5a5
    image.png

    20.返回指定规则下,返回字符最后出现在切片a中的位置

    package main
    
    import (
      "bytes"
      "fmt"
    )
    func main() {
      var a = []byte("123456f")
      var f = func (r rune)bool{
        return r == rune('f')
      }
      var lastIndex = bytes.LastIndexFunc(a,f)
      fmt.Println(lastIndex)
    }
    
    1594482-ebdb091dc581a74a
    image.png

    21.map方法处理数组数据

    func Map(mapping func(r rune) rune, s []byte) []

    package main
    
    import (
      "bytes"
      "fmt"
      "strconv"
    )
    
    func main() {
      var a = []byte("123456")
      var f = func (r rune)rune{
        s := string(r)
        num,err := strconv.Atoi(s)
        if(err != nil){
          fmt.Println(err)
          return rune(-1)
        }
        if(num > 5){
          return rune(-1)
        }
       return r
      }
      result := bytes.Map(f,a)
      
      fmt.Println(string(result))
    }
    
    1594482-490e0c097dfbeab9
    image.png

    Map 根据映射函数返回字节切片s的所有字符修改后的副本。如果映射返回负值,则字符将从字符串中删除而不会被替换。 s 和输出中的字符被解释为 UTF-8 编码的 Unicode 代码点


    22.将字符切片,重复n此组成新的切片

    package main
    
    import (
      "bytes"
      "fmt"
    )
    
    func main() {
      fmt.Printf("%s\n", bytes.Repeat([]byte("abc"),3))
    }
    

    1594482-04e471aa5a57ed79
    image.png

    23.用新的切片,替换切片a中的子切片的数据,替换n次

    package main
    
    import (
      "bytes"
      "fmt"
    )
    
    func main() {
      fmt.Printf("%s\n", bytes.Replace([]byte("121416"),[]byte("1"),[]byte("a"),2))
    }
    
    1594482-b8bc45da652e0189
    image.png

    24.将utf-8的字符切片转换为rune切片

    package main
    
    import (
      "bytes"
      "fmt"
    )
    
    func main() {
      s := []byte("121416我")
      r := bytes.Runes(s)
      fmt.Printf("%d,%d\n",len(s),len(r))
    }
    
    1594482-658711e456778af9
    image.png

    25.将切片按照字符切片b分割成多个子切片数组,不包含切片b

    package main
    
    import (
      "bytes"
      "fmt"
    )
    
    func main() {
      fmt.Printf("%s",bytes.Split([]byte("abcdef"),[]byte("d")))
    }
    

    1594482-5ba085183f0b942d
    image.png

    26.将切片按照字符切片b分割成多个子切片数组,包含切片b

    • 27.将切片按照字符切片b分割成n个子切片数组,如果数量达到n则不在继续分割
    • 28.切片字符中,按照空格划分成字符串,首字符设置大写
    • 29.切片全部转换为小写
    • 30.切片全部转换为小写
    • 31.从左边开始切割字符切片s中出现的字符切片b,返回剩余的数据
    • 32.从右边开始切割字符切片s中出现的字符切片b,返回剩余的数据
    展开全文
  • Bytes.toBytes()和String.getBytes()的区别

    千次阅读 2018-12-05 09:10:48
    toBytes()方法是将参数使用UTF-8的编码格式转换成byte[], getBytes()是用读取file.encoding的编码格式,然后用读取的格式进行转换, 所以,getBytes转换的byte[]的格式取决于操作系统和用户设置,最好统一只用toBytes()...

    toBytes()方法是将参数使用UTF-8的编码格式转换成byte[],
    getBytes()是用读取file.encoding的编码格式,然后用读取的格式进行转换,
    所以,getBytes转换的byte[]的格式取决于操作系统和用户设置,最好统一只用toBytes()方法。

    展开全文
  • bytes与str转化

    2020-10-21 15:27:26
    msg="我爱北京天安门" print(msg) 输出:我爱北京天安门 print(msg.encode(encoding="utf-8")) # str转bytes,编码 ...print(msg.encode(encoding="utf-8").decode(encoding="utf-8")) # bytes转s
  • golang标准库-bytes(第一节)

    千次阅读 2019-06-20 10:09:28
    bytes包是go提供的用来操作byte切片的工具包,包含对byte切片的查询,截取,替换,拼接,读取等方法,本章主要介绍查询,截取,替换,拼接等方法; 读取由于涉及buffer缓冲将在第二节讲解。本节内容全是介绍bytes包...
  • bytes、bytearry

    2019-04-15 11:17:03
    bytes、bytearry 字节(bytes) 定义:内存中连续排放的字节序列,一个字节8位,都是0和1组成 作用:主要解决字符串问题; 多字符就不能用一个字节来表示,需要用多个字节来表示;例如中文 字节序列 bytes 不...
  • Bytes和bits的区别

    万次阅读 2018-06-06 20:28:33
    基本概念Bit意为“位”或“比特”,是计算机运算的基础,属于二进制的范畴;Byte意为“字节”,是计算机文件大小的基本计算单位;这两者应用的场合不同。通常用bit来作数据传输的单位,因为物理层,数据链路层的传输...
  • Python `bytes` 类型是由单个字节构成的不可变序列。 Python `bytes` 可以称为二进制序列、或字节序列。 `bytes` 只负责以字节序列的形式(二进制序列的形式)来存储数据,至于这些数据到底表示什么内容(例如:...
  • Python中的bytes与bytearray详解

    千次阅读 2019-06-12 11:33:41
    bytes:不可变的字节序列 bytearray:可变的字节数组 字符与byts的区别: 字符串是字符组成的有序序列,字符可以使用编码来理解 bytes是字节组成的有序的不可变序列 bytearray是字节组成的有序的可变...
  • python byte类型与int、str类型转换

    千次阅读 2019-07-05 10:22:17
    bytes类型解释 python中的bytes类型可以类比为C中的uint8型数组,本质就是顺序排列的8bit二进制数字,例如以二进制方式从文件中读取时返回的就是bytes类型,或以b前缀的字符串也是bytes类型,如 a = b'abcd' ...
  • python str与bytes之间的转换

    万次阅读 多人点赞 2011-07-14 16:26:11
    # bytes object b = b"example" # str object s = "example" # str to bytes bytes(s, encoding = "utf8") # bytes to str str(b, e
  • 使用python3.5.1执行post请求时,一直报错"POST data should be bytes or an iterable of bytes. It cannot be of type str.",仔细对照教程后也未发现编写方法没有问题。  最后通过交流发现需要加在urlencode语句...
  • a bytes-like object is required,not 'str'

    万次阅读 2017-10-28 09:21:33
    今天用python3的request写爬虫的时候遇到这个...因为python3是bytes-like的,所以我们需要用split的话只能把它转为str # bytes object b = b"example" # str object s = "example" # str to bytes bytes(s, encodin
  • 分析了TypeError: a bytes-like object is required, not 'str'产生的原因并给出解决办法,并列举了Python内str和bytes相互之间的转化方法。
  • python3 中 str和bytes之间的转换

    万次阅读 2018-04-15 13:10:14
    以Unicode表示的str通过encode()方法可以编码为指定的bytes如果我们从网络或磁盘上读取了字节流,那么读到的数据就是bytes。要把bytes变为str,就需要用decode()方法初始一个字符串按utf-8,str转bytes按...
  • 问题描述: 在编译内核模块驱动时,如果出现如下警告信息:warning: the frame size of 1040 bytes is larger than 1024 bytes。主要是因为内核中设置了堆栈报警大小,其默认为1024bytes。我们主要将其修改为4096既...
  • HBase实验

    万次阅读 2020-07-13 18:22:07
    HBase完成学生表数据的添加与查询
  • 在python3中输入以下代码: 可以发现有以下报错: ... # bytes object s = "example" # str object sb = bytes(s, encoding = "utf8") # str to bytes 或者:sb = str.encode(s) ...
  • TypeError: expected string or bytes-like object

    万次阅读 2018-02-02 15:45:39
    正则参数,不是字符串,改成字符串就行了!
1 2 3 4 5 ... 20
收藏数 776,999
精华内容 310,799
关键字:

bytes