10_python笔记-文件操作
博客cpen_web
练习1
1.1 斐波那契数列
'''
0、1、1、2、3、5、8、13、21、34、……
在数学上，斐波那契数列以如下被以递推的方法定义：
F(0)=0，F(1)=1, F(n)=F(n - 1)+F(n - 2)（n ≥ 3，n ∈ N*）
'''
def fab(num):
if num==0:
return 0
elif num==1:
return 1
else:
return fab(num-1)+fab(num-2) # 注：关键
result = []
num = int(input('please input num:'))
for i in range(num):
result.append(fab(i))
print(result)
please input num:12
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
1.2 匿名函数
# 匿名函数
# 接收参数身高、体重
# 使用匿名函数定义bmi
bmi = lambda s,w: w/s**2
print(bmi(1.83,68))
20.305174833527424
1.3 用户密码复杂度验证
# ***************第3题：用户密码复杂度验证***************
# 用户密码复杂度验证（封装成函数）
# 长度超过8位（必须） +1分
# 包括大、小写字母，数字，其他符号，以上四种至少三种 +1分
# 不能有长度超过或等于3的子串重复 +1分
# 密码的评分等级，默认2分，以上条件满足一条加1分
# 返回密码的评分等级，及要改进的点：
# 如return 3，['长度小于8','密码没有由3种以上字符组成']
示例
# 密码复杂度
def length(pw):
global grade
global result
if len(pw) >=8:
grade += 1
else:
result.append("长度小于8")
def char(pw):
global grade
global result
flag = [0, 0, 0, 0] # 注：标志位
# symbol = ['_', '!', '@', '#']
for i in pw:
if i.isupper():
flag[0] = 1
elif i.islower():
flag[1] = 1
elif i.isdigit():
flag[2] = 1
# elif i in symbol:
# elif ord(i) < 48 or 58 <= ord(i) < 65 or 91 <= ord(i) < 97 or ord(i) >= 123:
else:
flag[3] = 1
if sum(flag) >= 3:
grade += 1
else:
result.append("密码没有由3种以上字符组成")
def sub_str(pw):
global grade
global result
for i in range(len(pw)-2):
if pw.count(pw[i: i+3]) >= 2:
result.append("长度超过或等于3的子串重复")
break
elif i == len(pw) -3:
grade += 1
def default():
global grade
global result
grade = 2
result = list()
pw = input("请输入密码:")
length(pw)
char(pw)
sub_str(pw)
return grade
def pw_complex():
print(f"return {default()},{result}")
pw_complex()
# 数字、字母、特殊字符的判断
result = [0,0,0,0] #（注：标志位）
def passwd_judge2(passwd:str): #（注：期望接收1个str类型。不是也没事）
for i in passwd:
if sum(result) >= 3: #（注：满足3种条件）
break
else:
if i.isupper(): # （注：大写）
result[0] = 1 # （注：标志位）
elif i.islower(): # （注：小写）
result[1] = 1 # （注：标志位）
elif i.isdigit(): # （注：数字）
result[2] = 1 # （注：标志位）
else: # （注：其他字符）
result[3] = 1 # （注：标志位）
return result
知识点2 文件的基本概念
2.1 什么是文件
文件是存放在外部介质 (如硬盘、U盘) 上的一组完整信息的集合。这些信息可为各种文字、 图形、图像、电影、音乐，甚至包括病毒程序等。
2.2 两种重要的文件类型
·文本文件（Text File）。文本文件是可直接阅读的，使用记事本打开即可看到文件的内 容。
·二进制文件（Binary File）。这类文件将数据按照它的进制编码的形式存储。如BMP。由于这类文件内容是二进制编码，使用记事本打开是显然是乱码，BMP可用图片查看器解码。
2.3 文本文件与二进制文件的优缺点
文件读取形式
·文本
·二进制
文本
优点：输出内容友好，不需要手动转换
缺点：一个字符占一个字节，文件占用的存储空间 较多，读写时需要转换（内存->显示）， 访问的时效率不高
二进制
优点：二进制文件中的数据与数据的内存中的表现形式一致。二进制文件在存储数据时非常紧凑，占用存储空间较少；在读写时不需要进行转换，具有较高的时间效率
缺点：二进制文件无法直接以字符形式输出，必须要经过一个转换过程
无论什么类型的文件，在硬盘/内存=> 二进制
·文本方式读：内存->看（转换）
·二进制方式读： 内存-> 看到一致
2.4 python3中的字符串类型
·bytes
转换：bytes->str ： decode(‘utf8’)
·str
转换： str->bytes： encode(‘utf8’)
注意：encode编码时可指定任何合适的编码方式，但decode解码时，一定需要对应的编码方式
示例
# 2种编码方式
# unicode 万国码 基本上所有的文字都给了一个编号
# ASCII码 对英文字符进行一个编号
# 编码 就是人类语言和机器语言的一种映射关系
# unicode 编码的具体实现方式 utf-8,utf-18,utf-31
# utf-8 可变长编码方式
# 一个英文字符占用一个字节
# 一个中文字符占用三个字节
# 中国 gbk gb2132 (注：对中文方式友好)
# gbk 一个字符占用2个字节 中文较多时，可以使用gbk编码方式，节省存储空间
# utf-8 为什么常用：因为1个英文占用1个字节，兼顾其他文符。占用内存较少
# 以什么方式加码，就要以什么方式解码
# 出现乱码 加码和解码方式不一致
# 文件打开乱码，一般情况下为加码和解码的方式不一致
>>> str1 = "中文"
>>> str1.encode("gbk")
b'\xd6\xd0\xce\xc4'
>>> str1.encode("gbk").decode("gbk")
'中文'
# A bin(65) a bin(97)
# 查看编码 ord
>>> a.add("d")
>>> a
{'c', 'b', 'a', 'd'}
>>> id(a)
139978717766152
>>> ord("a")
97
>>> ord("A")
65
>>> ord("中")
20013
>>> ord("文")
25991
>>> ord("“")
8220
>>> bin(20013)
'0b100111000101101' #（注：8位1个字节 0b1001110 00101101)
>>> bin(0b1001110)
'0b1001110' #（注：表示 - 号）
>>> str1 = "中文"
>>> str1.encode("utf-8") #（注：encode 加码，以什么方式存储，存在内存里)
b'\xe4\xb8\xad\xe6\x96\x87' #(注：英文一般三个字节)
>>> bin(0xe4) #（注：把二进制转换成十六进制，占一个字节。十六进制展示）
'0b11100100'
>>> bin(0xb8)
'0b10111000'
>>> str1 = "a"
>>> str1.encode("utf-8")
b'a' # (注:英文一般一个字节)
>>> str1 = "SA"
>>> str1.encode("utf-8")
b'SA'
>>> str1 = "中文"
>>> str1.encode("gbk") #（注：gbk一个中文占2个字节）
b'\xd6\xd0\xce\xc4'
2.5.1 文件的缓冲机制
·读操作：不会直接对磁盘进行读取，而是先打开数据流，将磁盘上的文件信息拷贝到缓冲区内，然后程序再从缓冲区中读取所需数据
·写操作：不会马上写入磁盘中，而是先写入缓冲区，只有在缓冲区已满或“关闭文件”时，才会将数据写入磁盘
2.5.2 文件缓冲区
·计算机系统为要处理的文件在内存中单独开辟出来的一个存储区间，在读写该文件时，做为数据交换的 临时“存储中转站”。
2.5.3 缓冲机制的好处
能够有效地减少对外部设备的频繁访问，减少内存与外设间的数据交换，填补内、外设备的速度差异，提高数据读写的效率。
知识点3 文件基本操作
3.1 访问文件操作过程
·打开文件 # 注：open
·读取文件 # 注：read
将信息读到内存
·写入文件
·关闭文件
保存文件并释放内存空间
3.2 打开文件（open）
·file : 要打开的文件名( str )
·mode: 打开文件的方式( str ) => text, bytes
·encoding: 文件编码方式（str）
·errors: 当发生编码错误时的处理方式（str）
‘ignore’或’strict’(默认)
·buffering: 缓存方式 ( int）
示例
注：文件打开 ==> open
注：指定不同编码方式打开文件
注：默认编码打开方式为None，跟平台语言编码环境有关，平台是utf-8/gbk这里就是utf-8/gbk
使用指定参数encoding，可以修改编码方式
>>> open
<built-in function open>
>>> help(open)
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)…………………… # 注：file文件 mode方式 buffering缓存
[root@localhost ~]# vim utf2.txt
[root@localhost ~]# file utf2.txt #（注：查看文件编码方式）
utf2.txt: ASCII text
[root@localhost ~]# file gbk2.txt
gbk2.txt: ISO-8859 text
[root@localhost ~]# cat utf2.txt
aaa
bbb
[root@localhost ~]# vim utf2.txt
[root@localhost ~]# cat utf2.txt
"中文"
aaa
bbb
[root@localhost ~]# file utf2.txt
utf2.txt: UTF-8 Unicode text
>>> fp = open("utf2.txt") # 打开文件（open）
>>> fp.read()
'中文\naaa\nbbb\nccc\n'
>>> fp = open("win_utf.txt",encoding = "gbk") # （注：encoding 修改编码方式）
文件编码方式转换
[root@localhost ~]# iconv -f gbk -t utf-8 win-utf.txt > win-utf-2.txt
windows utf-8 与linux utf-8文本
·linux
>>> fp = open("utf.txt")
>>> fp.read()
'中文\naaa\nbbb\nccc\n'
·windows
>>> fp = open("win-utf.txt")
>>> fp.read()
'\ufeffwindow 中文' # 注：前面有\ufeff
>>> fp = open("win-utf.txt",encoding = "utf-8-sig") # 这样就没了
>>> fp.read()
'window 中文'
检测文件编码
判断文件编码-chardet模块
#以二进制方式打开
Python里检测文件编码，安装模块
[root@localhost ~]# pip3 install chardet
>>> import chardet # 注：导入模块
>>> fp = open("utf2.txt","rb") # 注：以二进制方式打开。不然报错
>>> chardet.detect(fp.read())
{'encoding': 'utf-8', 'confidence': 0.7525, 'language': ''}
示例：errors: 当发生编码错误时的处理方式（str） ‘ignore’或’strict’(默认)
ignore 发生错误时不报错， 默认strict
>>> fp_gbk = open("utf.txt",encoding = "gbk")
>>> fp_gbk.read()
Traceback (most recent call last): # 注：报错
File "<stdin>", line 1, in <module>
UnicodeDecodeError: 'gbk' codec can't decode byte 0xad in position 2: illegal multibyte sequence
>>> fp_gbk2 = open("utf.txt",encoding = "gbk", errors="ignore") # 注：不报错
>>> fp_gbk2.read()
'涓鏂\naaa\nbbb\nccc\n'
>>> fp = open("utf.txt") # 打开当前路径下的文件。绝对路径打开指定文件
>>> fp.read()
'中文\naaa\nbbb\nccc\n'
>>> fp = open("utf.txt")
>>> fp.readlines()
['中文\n', 'aaa\n', 'bbb\n', 'ccc\n'] # 一行变成列表中的元素
[root@localhost ~]# cat utf.txt
中文
aaa
bbb
ccc
知识点3.3
打开文件-文件编码
·encoding: 文件的编码方式( str )
·encoding的默认值：None， 不同的平台打开的方式不一样
·encoding is the name of the encoding used to decode or encode the file. This should only be used in text mode. The default encoding is platform dependent。
为什么需要编码
·对于计算机来说，所有信息都是由0和1组成的二进制。 人类无法仅用二进制就来完成计算机的各种操作
·字符编码解决人与计算机之间的沟通问题。
常见编码
编码名称 特点 表示范围
ASCII 除去最高位，用7位表示 128个（字母、数字、特殊字符）
扩展ASCII 用8位表示 256个（拉丁文、字母、数字、特殊字符
GB2312 表示中文汉字 7000多个
GBK 为了扩展更多的中文汉字字符 2W
Unicode Unicode只是一个符号集，只规定的字符 所对应的码点，并没有指定如何存储 Unicode表包含了1114112个码点，又称 万国码
UTF-8 可变长的表示方式，节省磁盘空间 英文国家-1字节
其他的-2字节、3字节、4字节
中文：3个字节
案例3.4 文件编码案例
制作2个文件
·“gbk.txt” 保存为GBK编码
·“utf8.txt” 保存为UTF-8编码
测试打开文件
·用默认方式
·用正确的编码方式打开
·显示地指定编码方式
[root@localhost ~]# vim gbk.txt
[root@localhost ~]# iconv -f utf-8 -t gbk gbk.txt > gbk2.txt
[root@localhost ~]# vim utf8.txt
[root@localhost ~]# file gbk2.txt
gbk2.txt: ISO-8859 text
[root@localhost ~]# file utf8.txt
utf8.txt: UTF-8 Unicode text
>>> fp = open("gbk2.txt", encoding = "gbk")
>>> fp.read()
'中文\naaa\nbbb\nccc\n'
>>> fp = open("utf8.txt")
>>> fp.read()
'中文\naaa\nbbb\n'
知识点3.5
打开文件-mode（rwxa任选其一, tb任选其一，+是可选项）
方式 说明 文件存在 文件不存在
‘r’ |读模式 (默认) |正常打开 |出错
‘w’ |写模式 |写入，会覆盖源文件内容 |创建新文件
‘x’ |创建新文件，并写入内容 |报错：FileExistsError |创建新文件，并写入内容
‘a’ |追加模式 |在原内容后追加 |创建新文件
‘b’ |二进制模式 |python3下网络传输，只能用bytes格式， ‘rb’, ‘rb+’
‘t’ |文本模式 (默认) |‘r’, ‘w’, ‘x’
‘+’
读写模式
r+ |可读写。文件不存在会报错
w+ |可读写。将文件内容清空再写
a+ |可读可追加。不存在则创建；存在则只追加内容
x+ |可读写。文件存在会报错
示例：以读模式打开（默认模式）
# 只读，不能编写，文件不存在会报错
>>> fp = open("utf.txt") #（注：默认只读）
>>> fp = open("utf.txt",mode="r") #（注：关键字参数）
>>> fp = open("utf.txt","r") #（注：默认参数）
>>> fp.write("a") #（注：不能编写）
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
io.UnsupportedOperation: not writable
>>> fp = open("utf333.txt","r") #（注：文件不存在会报错）
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
FileNotFoundError: [Errno 2] No such file or directory: 'utf333.txt'
示例：写模式 -w
文件保存在磁盘上，往里面写是有写缓存的，write在内存上。在进程结束，或者缓冲区满的时候（缓冲区有大小）会往文件里面写。
立马生效：>>> fp.close() 会写在磁盘上，之间的内容不存在了（覆盖写）
#写模式 - w 已覆盖方式写入，文件不存在就新建。跟shell中的>重定向类似
写缓冲，默认只有在缓冲区满，或者文件对象关闭（fp.close()），或者程序退出的时候，才会写到磁盘
>>> fp = open("utf.txt","w")
>>> fp.read()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
io.UnsupportedOperation: not readable
>>> fp.write("this is test")
12
>>> fp.close() #（注：关闭对文件的连接）
[root@localhost ~]# cat utf.txt
this is test[root@localhost ~]#
>>> fp = open("utf2.txt","w") #（注：没有就新建）
>>> fp.write("abc")
3
示例：写模式 -x 新建文件并且写入。如果文件存在就报错
>>> fp = open("utf3.txt","x")
>>> fp.write("this is x test")
14
>>> fp.close()
[root@localhost ~]# cat utf3.txt
this is x testthis is a test[root@localhost ~]#
文件模式
t --> text 默认文本模式
b --> 二进制模式
读写模式
r+ w+ a+ x+
示例：r+
>>> fp = open("utf3.txt","r+")
>>> fp.write("aaaaa")
5
>>> fp.flush() #（注：强制将缓冲区的内容 存放到磁盘）
[root@localhost ~]# vim utf3.txt
[root@localhost ~]# cat utf3.txt
first
second
>>> fp = open("utf3.txt","r+")
>>> fp.write("aaaaaaa")
7
>>> fp.close()
[root@localhost ~]# cat utf3.txt
aaaaaaaecond
示例：w+ 可读写。将文件内容清空再写
>>> fp = open("utf3.txt", "w+")
>>> fp.read()
''
练习3.6
以下是需要什么模式打开
读取本地图片 # 以二进制方式打开
将网络上的图片保存到本地 # 以二进制方式打开
接收用户输入，将内容保存到文件末尾 # a
接收用户输入，将内容保存到文件，如果文件已存在，则覆盖原内容 # w
知识点3.7 关闭文件
·为什么要关闭文件
·文件忘记关闭
·遇到异常怎么办
知识点3.8 关闭文件-用with语句打开（建议）
#>>> with open(“utf3.txt”, “r”) as f1: #（注：用with打开，自动帮你关闭连接[fp.close()]，自动写入）
示例
[root@localhost ~]# cat utf3.txt
中文
aaa
bbb
>>> with open("utf3.txt", "r") as f1:
... print(f1.read()) #（注：缩进）
...
中文
aaa
bbb
知识点3.9 读取文件内容
方式 说明 结果类型
f.tell() 文件光标->(字节位置) 整数 int
f.seek(cookie, whence=0) 移动光标位置cookie=> 偏移量 None whence=> 相对位置 注意：1、2只能用b模式打开才可以
(0-> 开始, 1->当前, 2->末尾)
fp 文件对象 IOWrapper，可迭代对象
fp.readlines() 返回当前到文末的一个列表 列表 list
f.read() 返回当前到文末(字符串)，可指定字符数 字符串 str
f.readline() 返回当前位置到行末 字符串 str
示例
[root@localhost ~]# cat aa.txt
你好
世界
welcome to sanchuang
>>> fp.read(10) #（注：读的是10个字符）（注：不是字符表示的开始字节会报错）
'你好\n世界\nwelc'
>>> fp.tell() #（注：查看文件光标->(字节位置)）
18
>>> fp.seek(10)
10
>>> fp.read(10) #（注：从光标的后面往后读）
'界\nwelcome '
二进制模式打开文件
>>> fp = open("aa.txt","rb")
>>> fp.tell() #（注：当前光标所在位置->(字节位置)）
0
>>> fp.read(10) #（注：读的是10个字节）（注：文本模式读的是字符数）
b'\xe4\xbd\xa0\xe5\xa5\xbd\n\xe4\xb8\x96'
>>> fp.read(10).decode("utf-8") #（注：读的是10个字节）
'界\nwelcom'
>>> fp.seek(3,1) #（注：光标移动3格，0-> 开始, 1->当前, 2->末尾）
23
>>> fp.read(3)
b'o s'
>>> fp.seek(-5,2) #（注：移动光标位置，0-> 开始, 1->当前, 2->末尾）
30
>>> fp.read()
b'uang\n'
>>> fp.read()
b''
>>> fp.seek(0) #（注：重新读，只能将光标移到最开始的位置）
0
>>> fp.read()
b'\xe4\xbd\xa0\xe5\xa5\xbd\n\xe4\xb8\x96\xe7\x95\x8c\nwelcome to sanchuang\n'
>>> fp = open("aa.txt","r")
>>> fp.read()
'你好\n世界\nwelcome to sanchuang\n'
>>> fp.readlines()
[]
>>> fp.seek(0)
0
>>> fp.readlines() #（注：列表形式）
['你好\n', '世界\n', 'welcome to sanchuang\n']
>>> fp.readline()
''
>>> fp.seek(0)
0
>>> fp.readline() #（注：每次读取一行）
'你好\n'
>>> fp.readline()
'世界\n'
>>> fp.readline()
'welcome to sanchuang\n'
>>> fp.readline()
''
练习4.0
准备一个example.txt文件， 里面随便写入些内容(如一首歌词)
·读前5行。
·读全文
·读取最后12字节 => str格式
·读取最后4个汉字 => str格式
·读前5行
方法1
>>> fp = open("example2.txt")
>>> for i in range(5):
... fp.readline()
...
'是他 \n'
'是他 \n'
'是他 \n'
'就是他\n'
'我们的朋友\n'
方法2（推荐）
>>> for i in fp: #（注：fp可以直接循环，循环每次取文件每一行数据）
... print(i)
...
小哪吒
上天他比
天更高
下海他比
海更大
智斗妖魔
降鬼怪
方法3：fp.readlines()返回的是列表，取前五个元素 （文件大的话不可取）
·读全文
>>> fp.seek(0)
0
>>> fp.read()
'是他 \n是他 \n是他 \n就是他\n我们的朋友\n小哪吒\n上天他比\n天更高\n下海他比\n海更大\n智斗妖魔\n降鬼怪\n\n'
>>> fp.seek(0)
0
>>> fp.readlines()
['是他 \n', '是他 \n', '是他 \n', '就是他\n', '我们的朋友\n', '小哪吒\n', '上天他比\n', '天更高\n', '下海他比\n', '海更大\n', '智斗妖魔\n', '降鬼怪\n', '\n']
·读取最后12字节
注：转换成二进制形式会比较好（二进制 一个就是一个字节）
示例
>>> fp2 = open("example2.txt","rb")
>>> fp2.seek(-12,2) # 注：光标移动到末尾，以末尾为初始的状态 -12 往前走
118
>>> fp2.read() # 注：读出来是字节形式
b'\n\xe9\x99\x8d\xe9\xac\xbc\xe6\x80\xaa\n\n'
>>> fp2.seek(-12,2)
118
>>> fp2.read().decode("utf-8") # 注：decode转换成人类能够读的懂的形式
'\n降鬼怪\n\n'
#注：string变成字节码用encode，字节码变成sting用encode（解码）
·读取最后4个汉字 => str格式
同理（假设后面全是汉字）
练习4.1 读取一个文件,显示除了以井号(#)开头的行以外的所有行。
方法1（推荐）
>>> fp3 = open("example.txt","r")
>>> for i in fp3: #（注：一行一行读）
... if not i.startswith("#"): # 注：以“#”开头
... print(i)
方法2：fp3.readlines() 返回的是列表。for i in 循环列表，到列表里面去找，判断每一个元素 是否以 # 号开头 （文件大的话不可取）
>>> fp3.seek(0)
0
>>> fp3.readlines()
['是他 \n', '是他 \n', '是他 \n', '就是他\n', '我们的朋友\n', '小哪吒\n', '上天他比\n', '天更高\n', '下海他比\n', '海更大\n']
知识点 4.2写文件
f.write(‘something’)
写文件 （注：写缓存）
·为什么不实时写入磁盘
·硬盘是慢设备，频率读写会增大磁盘压力，产生瓶颈
什么时候会写入磁盘
·f.flush() # 注：强制刷新
·f.close() # 注：文件关闭
·buffer设置（默认：io.DEFAULT_BUFFER_SIZE )
0 => 实时写入 （binary mode） （注：二进制模式）
1 => 行缓存 （ text mode） => \n （注：行缓存，文本模式。会产生很多io）
其他数字n => 缓冲区大小n : 2*4096
·默认情况 程序退出\缓冲区满 写入磁盘
示例
默认情况 程序退出\缓冲区满 写入磁盘
>>> fp = open("aa.txt","a+")
>>> fp.write("test1")
5
>>> fp.flush()
>>> fp_buff = open("aa.txt","a+",buffering=1) #（注：buffering=1 行缓存）
>>> fp_buff.write("test2")
5
>>> fp_buff.write("test3\n") #（注：行缓存。\n换行 才会写入）
6
>>> fp_buff = open("aa.txt","a+",buffering=2) #（注：缓冲区大小2*4096）
>>> fp_buff.write("fp_buff_3")
9
>>> fp_buff.write("\n buffering test")
16
>>> fp_buff.write("a*4096")
6
>>> fp_buff.write("a"*4096)
4096
>>> fp_buff.write("a"*4096)
4096
fp_bufffp_buff_2[root@localhost ~]# cat aa.txt #（注：缓冲区写满了，保存）
你好
世界
welcome to sanchuang
test1test2test3
fp_bufffp_buff_2fp_buff_3
buffering testa*4096aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa………………………………
知识点4.3 案例
·f.flush() 强行写入
·f.close() 关闭文件
·buffer参数默认值
·buffer参数不缓存
·buffer参数行缓存
·buffer参数设置指定大小
知识点4.4 文件对象其他方法
方式 说明
f.fileno() 返回文件描述符
f.readable() 文件是否可读
f.seekable() 指针是否可移动
f.truncate(n) 从文件头开始截取指定参数的n个字节，其它的全部删除。
f.writable() 文件是否可写
示例
>>> fp_buff.truncate(10)
10
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
