在内存中读写,StringIO、BytesIO,read、readline、readlines、getvalue

古城微笑少年丶 2023-02-19 06:24 63阅读 0赞

## 一.StringIO  在内存中读写字符 ##

python StringIO模块主要用于在内存缓冲区中读写数据，模块中只有一个StringIO类，它的可用方法都在类中，StringIO的行为与file对象非常像，但它不是磁盘上文件，而是一个内存里的“文件”，我们可以像操作磁盘文件那样来操作StringIO。

s=StringIO(\[buf\])    \#\[buf\]可有可无

**StringIO类中的方法：**  
**s.read(\[n\])**  
参数n限定读取长度，int类型；缺省状态为从当前读写位置读取对象s中存储的**所有数据**。读取结束后，读写位置被移动。  
\----------------------  
**s.readline(\[length\])   \#据说readline比read效率低得多.**  
参数length限定读取的结束位置，int类型，缺省状态为None：**从当前读写位置读取至下一个以“\\n”为结束符的当前行**。读写位置被移动。  
\----------------------  
**s.readlines(\[sizehint\])**  
参数sizehint为int类型，缺省状态为**读取所有行**并作为**列表**返回，除此之外从当前读写位置读取至下一个以“\\n”为结束符的当前行。读写位置被移动。  
\----------------------  
s.**write**(s)  
从读写位置将参数s写入给对象s。参数s为str或unicode类型。读写位置被移动。  
\----------------------  
s.writelines(list)  
从读写位置将list写入给对象s。参数list为一个列表，列表的成员为str或unicode类型。读写位置被移动。  
\----------------------  
s.getvalue()  
此函数没有参数，无论读写位置在哪里，都能够返回对象s中的**所有数据**。  
\----------------------  
s.**truncate**(\[size\])  
1)有size参数

无论读写位置在哪里，都从起始位置开始，裁剪size字节的数据。

2)不带size参数

将当前读写位置之前的数据，裁剪下来。  
\----------------------  
s.tell()  
返回当前读写位置。  
\----------------------  
**s.seek(pos\[,mode\])**  
移动当前读写位置至pos处，可选参数mode为0时将读写位置移动至pos处，  
为1时将读写位置从当前位置起向前或向后移动|pos|个长度，  
为2时将读写位置置于末尾处再向前或向后移动|pos|个长度；

mode的默认值为0。  
\----------------------  
**s.close()**  
释放缓冲区，执行此函数后，数据将被释放，也不可再进行操作。  
\----------------------  
s.isatty()  
此函数总是返回0。  
\----------------------  
s.flush()  
刷新内部缓冲区。  
\--------------------

from io import StringIO
    
    f=StringIO()
    
    f.write('hello')

输出:5  \#(表示有5个字符,但不显示内容hello)

print(f)  
输出:<\_io.StringIO object at 0x000001BA80E09438>

要输出f里写的内容,可用getvalue()、read,,,

from io import StringIO
    f=StringIO()
    f.write('hello')
    
    s=f.getvalue()
    
    print(s)

输出:hello

from io import StringIO
    f=StringIO()
    f.write('hello')
    
    s=f.read()
    
    print(s)

没有打印输出,因为read和write操作之后,指针都会移至尾部,从尾部的下一位开始输出,空的.

#参阅https://www.liaoxuefeng.com/discuss/969955749132672/1281886345232417之松鼠Yanis的回复
    f=StringIO('abc')
    f.read() #返回'abc'
    f.read() #返回'' 因为使用过一次read之后指针会发生移动
    f.getvalue() #返回'abc' 因为getvalue不受指针影响
    
    f=StringIO('')
    f.write('abc4')
    f.read() #返回'' 因为write已经使指针发生了移动
    f.getvalue() #返回'abc4' 因为getvalue不受指针影响
    f.seek(0) #解决方法：用seek将指针归零
    f.read() #返回'abc4'

**read(),readline()和getvalue()**

**readline(),每次读一行,如有换行符则包括换行符。write()和read()每次操作之后都会使指针发生移动,用seek(0)可以往日重现.**

使用f.read()必须得使用f.seek先进行指针定位

如果要输出全部，则

f.seek(0)

f.read()

等同于f.getvalue()

当用f.read()、f.readline()读取文件时，已读的部分就从文件消失了，剩下可读的就只有未读的。

from io import StringIO
    f=StringIO('Hello!\nHi!\nGoodbye!')
    while True:
        s=f.readline()
        if s=='':  #读到空的时候,跳出循环.
            break
        print(s.strip())

输出:

Hello!
    Hi!
    Goodbye!

例:

from io import StringIO
    f=StringIO('abc')
    print(f.getvalue()) #输出abc
    print('开始指针位置:',f.tell())#输出0,当前指针位置为0,getvalue后指针位置没有变化。tell()方法显示指针位置
    f.write('hello\np')  #\n两个在一块算一个字符.
    print('getvalue取值输出:',f.getvalue()) #hello,不见abc;前面write()覆盖初始abc,后面再有write的时候,作用就是追加了.
    print('write之后指针位置:',f.tell()) #7,write之后指针位置移动到7(最后一个字符p的位置号)
    f.seek(0) #指针位置移到开头0位.
    print('从0位开始输出:',f.readline(),"readline()读取一行(如有换行符则包括换行符,所以本行是在输出hello之后,换行输出)") 
    
    print(f.tell())  #6,readline包括换行符\n(\和n两个在一起算一个字符,所以是6)
    print('再读一行:',f.readline()) #尾行,没有换行符,所以后面没有空行输出.
    print(f.tell())
    f.write('want')#在之前的hello\np后追加want
    print(f.getvalue())

上面代码输出如下:

abc
    开始指针位置: 0
    getvalue取值输出: hello
    p
    write之后指针位置: 7
    从0位开始输出: hello
     readline()读取一行(如有换行符则包括换行符,所以本行是在输出hello之后,换行输出)
    6
    再读一行: p
    7
    hello
    pwant

**如何不换行?用readline() ,使用strip()方法**

from io import StringIO
    f=StringIO('abc')
    f.write('hello\np')  # \n两个在一块算一个字符.
    f.seek(0) #指针位置移到开头0位.
    print('从0位开始输出:',f.readline(),"readline()读取一行(如有换行符则包括换行符,所以本行是在输出hello之后,换行输出)") #
    
    f.seek(0) #指针位置移到开头0位.
    print('从0位开始输出:',f.readline().strip(),"输出时f.readline().strip(),去除了首尾的空格及换行符,所以本行没有换行输出)")

**关于strip(),参阅**[https://www.runoob.com/python/att-string-strip.html][https_www.runoob.com_python_att-string-strip.html]

Python strip()方法
    Python 字符串 Python 字符串
    
    描述
    Python strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。
    
    注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。
    
    语法
    strip()方法语法：
    
    str.strip([chars]);
    参数
    chars -- 移除字符串头尾指定的字符序列。
    返回值
    返回移除字符串头尾指定的字符生成的新字符串。
    
    实例
    以下实例展示了strip()函数的使用方法：
    
    实例(Python 2.0+)
    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
     
    str = "00000003210Runoob01230000000"; 
    print str.strip( '0' );  # 去除首尾字符 0
     
     
    str2 = "   Runoob      ";   # 去除首尾空格
    print str2.strip();
    以上实例输出结果如下：
    
    3210Runoob0123
    Runoob
    从结果上看，可以注意到中间部分的字符并未删除。

##  二.BytesIO在内存中操作二进制数据 ##

创建一个BytesIO，然后写入一些bytes：

from io import BytesIO
    f = BytesIO()
    f.write('中文'.encode('utf-8'))  #请注意，写入的不是str，而是经过UTF-8编码的bytes
    
    print(f.getvalue())

b'\xe4\xb8\xad\xe6\x96\x87'

--------------------

### 另有能者作如下说: ###

# StringIO和BytesIO
    
    # stringIO 比如说，这时候，你需要对获取到的数据进行操作，但是你并不想把数据写到本地硬盘上，这时候你就可以用stringIO
    from io import StringIO
    from io import BytesIO
    def outputstring():
        return 'string \nfrom \noutputstring \nfunction'
    
    s = outputstring()
    # 将函数返回的数据在内存中读
    sio = StringIO(s)
    # 可以用StringIO本身的方法
    print(sio.getvalue())
    # 也可以用file-like object的方法
    s = sio.readlines()
    for i in s:
        print(i.strip())

输出:

string 
    from 
    outputstring 
    function
    string
    from
    outputstring
    function

# 将函数返回的数据在内存中写
    def outputstring():
        return 'string \nfrom \noutputstring \nfunction'
    
    s = outputstring()
    sio = StringIO()
    sio.write(s)
    # 可以用StringIO本身的方法查看
    s=sio.getvalue()
    print(s)
    
    # 如果你用file-like object的方法查看的时候，你会发现数据为空
    
    sio = StringIO()
    sio.write(s)
    for i in sio.readlines():
        print(i.strip())
    
    # 这时候我们需要修改下文件的指针位置
    # 我们发现可以打印出内容了
    sio = StringIO()
    sio.write(s)
    sio.seek(0,0)
    print(sio.tell())
    for i in sio.readlines():
        print(i.strip())
    
    # 这就涉及到了两个方法seek 和 tell
    # tell 方法获取当前文件读取指针的位置
    # seek 方法，用于移动文件读写指针到指定位置,有两个参数，第一个offset: 偏移量，需要向前或向后的字节数，正为向后，负为向前；第二个whence: 可选值，默认为0，表示文件开头，1表示相对于当前的位置，2表示文件末尾
    # 用seek方法时，需注意，如果你打开的文件没有用'b'的方式打开，则offset无法使用负值哦
    
    
    
    # stringIO 只能操作str，如果要操作二进制数据，就需要用到BytesIO
    # 上面的sio无法用seek从当前位置向前移动，这时候，我们用'b'的方式写入数据，就可以向前移动了
    bio = BytesIO()
    bio.write(s.encode('utf-8'))
    print(bio.getvalue())
    bio.seek(-36,1)
    print(bio.tell())
    for i in bio.readlines():
        print(i.strip())

string 
    from 
    outputstring 
    function
    0
    string
    from
    outputstring
    function
    b'string \nfrom \noutputstring \nfunction'
    0
    b'string'
    b'from'
    b'outputstring'
    b'function'

--------------------

### 又有能者说: ###

当使用StringIO()去初始化的时候，其指针是指向0的位置；而如果是用write的方法的时候，其指针则是会移动到后面的。

#write的方法本质上是追加
    from io import StringIO
    from io import BytesIO
    a = StringIO()
    a.write('abc')
    a.getvalue()
    a.write('456')
    a.getvalue()
    
    abc456

write的方法本质上是追加,但追加的位置与当时指针位置有关:

sio = StringIO('abc') #这里是初始化，指针指向0 sio.getvalue() 'abc'
    sio = StringIO('def') #这里是再次初始化，指针仍然指向0 
    sio.getvalue() 'def' #def覆盖原值abc 
    sio.write('ghi') #这里要注意了，虽然是追加，但是由于指针仍然是0，所以实际上仍然会覆盖掉原值
    sio.getvalue() 'ghi'
    sio.write('ghi') #上面第一次追加以后，指针就向后移动，所以此处才真正起到追加的效果
    sio.getvalue() 'ghighi'

a = StringIO('abcdefg')
    a.getvalue()
    a.write('12')
    a.getvalue()
    
    12cdefg

小结:.getvalue()可以查看整个输入后的情况 .

write()的初始位置是0，输入多少后到多少位

直接构造之后初始位置不变还是0

**.seek()**是直接去某个position (*seek 方法，用于移动文件读写指针到指定位置,有两个参数，**第一个offset: 偏移量**，需要向前或向后的字节数，正为向后，负为向前；**第二个whence:** 可选值，默认为0，表示文件开头，1表示相对于当前的位置，2表示文件末尾.  
\# 用seek方法时，如果你打开的文件没有用 '**b'**的方式打开，则offset无法使用负值，*如果whence不为0 ，那么 offset就必须为0

*\#*只有采用**二进制模式**打开的文件，才允许使用从文件末尾和文件当前位置进行偏移定位，非二进制的文本文件，不允许使用基于文件末尾和文件当前位置进行偏移定位。因此文本文件只能基于文件开始位置进行偏移定位；)

关于seek例1:

from io import BytesIO
    f = BytesIO()
    f.write('中华人民共和国中华人民共和国'.encode('utf-8'))
    f.seek(-5,2)
    f.write('万岁'.encode('utf-8'))
    f.write('万岁'.encode('utf-8'))
    print(f.readline())
    print(f.getvalue())

关于seek例2:

from io import BytesIO
    f = BytesIO()
    f.write('123456789'.encode('utf-8'))
    #从文尾
    f.seek(-5,2) #从文件尾开始向前5个字符.负号向左
    print(f.readline())
    #从文头
    f.seek(5,0) #从文件头开始  正数向右,跳过5个,从第6个开始
    print(f.readline())
    
    f.seek(3)
    #从当前位
    f.seek(4,1) #从当前位开始,偏移4位,即当前位3加上偏移位4共7位,从下一位即第8位开始到尾
    print(f.readline())
    
    print(f.getvalue())

.tell()可以查看当前位置 ps：read()读取完位置自动到末尾

例子小结:
    from io import StringIO
    
    # 初始化，说明指针指向0
    stringIO = StringIO("abc")
    print(stringIO.getvalue())
    print(stringIO.tell())
    
    # 写入字符d
    stringIO.write("d")
    print(stringIO.getvalue())
    print(stringIO.tell())
    
    # 移动指针到末尾
    stringIO.seek(0, 2)
    print(stringIO.getvalue())
    print(stringIO.tell())
    
    # 写入字符e
    stringIO.write("e")
    print(stringIO.getvalue())
    print(stringIO.tell())

结果

abc
    0
    dbc
    1
    dbc
    3
    dbce
    4

[https_www.runoob.com_python_att-string-strip.html]: https://www.runoob.com/python/att-string-strip.html