zoukankan      html  css  js  c++  java

  • 文件的处理

    字符编码

    一、字符编码的种类

    1. ASCII

      用一个Byte表示一个字符，1byte=8bits，包含英文、拉丁文和键盘其他字符。

    2. GBK

      中国字符编码表，2Bytes代表一个字符。

    3. Shift_Jis

      日本字符编码表

    4. Euc_kr

      韩国字符编码表

    5. Unicode

      万国码，用2Bytes代表一个字符，兼容所有字符编码。优点是字符到二进制数据的转换速度快，缺点是占用空间大。

    6. UTF-8

      Unicode的改进版，对英文字符用1Byte表示，对中文字符用3Bytes。优点是节省空间，缺点是字符到二进制数据的转换速度慢，因为每次都需要计算出字符需要多长的Bytes才能够准确表示。

    • 内存中使用的编码是unicode，用空间换时间（程序都需要加载到内存才能运行，因而内存应该是尽可能的保证快）
    • 硬盘中或者网络传输用utf-8，网络I/O延迟或磁盘I/O延迟要远大与utf-8的转换延迟，而且I/O应该是尽可能地节省带宽，保证数据传输的稳定性。

    二、程序的执行

    1. python解释器此时就是一个文本编辑器。从硬盘中读取test.py的内容到内存中。python解释器会读取py文件的第一行内容，#coding:xxx，来决定以什么编码格式来读入内存。可以用sys.getdefaultencoding()查看，如果不在python文件指定编码格式，那就使用默认的。python2中默认使用ascii，python3中默认使用utf-8

    2. 读取已经加载到内存的代码（unicode编码的二进制），然后执行，执行过程中可能会开辟新的内存空间。

      内存的编码使用unicode，不代表内存中全都是unicode编码的二进制，

      在程序执行之前，内存中确实都是unicode编码的二进制,比如从文件中读取了一行x="hello",其中的x，等号，引号，地位都一样，都是普通字符而已，都是以unicode编码的二进制形式存放与内存中的

      但是程序在执行过程中，会申请内存（与程序代码所存在的内存是俩个空间），可以存放任意编码格式的数据，比如x="hello",会被python解释器识别为字符串，会申请内存空间来存放"hello"，然后让x指向该内存地址，此时新申请的该内存地址保存也是unicode编码的hello,如果代码换成x="hello".encode('utf-8'),那么新申请的内存空间里存放的就是utf-8编码的字符串hello了 。

    3. 产生结果，将结果发送到终端，不同终端支持特定的字符编码。

    三、encode 和 decode

    1. python2 默认ASCII码
    #coding=utf-8
#Python2中默认是ASCII码，一般会加入以utf-8编程
a = '编码'                       # a是utf-8类型
b = a.decode('utf-8')       # b是Unicode类型
c = b.encode('gbk')        #c是gbk类型
d = c.decode('gbk').encode('utf-8')   #先将c转换成Unicode，再转成utf-8
print a, type(a)    # 编码 <type 'str'>
print b, type(b)    # 编码 <type 'unicode'>
print c, type(c)    # ���� <type 'str'>
print d, type(d)    # 编码 <type 'str'>
    1. Python3中默认是unicode
    a = '编码'                       # a是unicode类型
b = a.encode('utf-8')       # b是utf-8类型
c = a.encode('gbk')        #c是gbk类型
print(a, type(a))    # 编码 <class 'str'>
print(b, type(b))    # b'xe7xbcx96xe7xa0x81' <class 'bytes'>
print(c, type(c))    # b'xb1xe0xc2xeb' <class 'bytes'>

    文件处理

    

    什么是文件
    

    

    操作系统提供的虚拟的概念，用于存储信息（用二进制存储信息）
    

    

    什么是文件处理
    

    

    修改存储的信息
    

    

    操作文件的流程
    

      

    1. 

      打开文件
      

      使用open()函数打开 文件, f = open(r'test.py','w',encoding='utf8')
      

      括号内参数分别为: 文件路径（路径地址前的r 可以使路径中的特殊意义字符失效）、打开方式、读取编码方式
      

      2. 

    2. 

      修改读取文件
      

      f.write() f.read()分别为写入信息、读取信息
      

      3. 

    3. 

      保存文件
      

      f.flush()快速保存
      

      4. 

    4. 

      关闭文件
      

      f.close()
      

      5. 

    


      

    1. 

      文件操作流程
      

        

      • 打开文件，得到文件句柄并赋值给一个变量
        • 

      • 通过句柄对文件进行操作
        • 

      • 关闭文件
        • 

      

      2. 

    2. 

      python中的文件操作
      

      #1. 打开文件，得到文件句柄并赋值给一个变量
f=open('a.txt','r',encoding='utf-8') #默认打开模式就为r

#2. 通过句柄对文件进行操作
data=f.read()

#3. 关闭文件
f.close()
      

      3. 

    3. 

      f=open('a.txt','r')的过程分析
      

        

      • 由应用程序向操作系统发起系统调用open(...)
        • 

      • 操作系统打开该文件，并返回一个文件句柄给应用程序
        • 

      • 应用程序将文件句柄赋值给变量f
        • 

      

      4. 

    4. 

      文件的回收
      

      打开一个文件包含两部分资源：操作系统级打开的文件+应用程序的变量。在操作完毕一个文件时，必须把与该文件的这两部分资源一个不落地回收，回收方法为：
      

      1、f.close() #回收操作系统级打开的文件
2、del f #回收应用程序级的变量

# 其中del f一定要发生在f.close()之后，否则就会导致操作系统打开的文件还没有关闭，白白占用资源，
# 而python自动的垃圾回收机制决定了我们无需考虑del f，这就要求我们，在操作完毕文件后，一定要记住      # f.close()
      

      用with关键字来管理上下文能自动关闭文件
with open('a.txt','w') as f:
    pass
      

      5. 

    


    

    文件的三种打开方式
    

    

    一般默认的读写内容的模式为t模式 可以忽略直接写为r 、w、a
    

    


    模式含义
    
    


    
‘r'
只读模式【默认模式，文件必须存在，不存在则抛出异常】

    

    
‘w'
只写模式【不可读，不存在则创建，存在则清空内容】

    

    
‘a'
追加模式【不可读，不存在则创建，存在则追加内容】

    

    
‘b'
以二进制模式操作文件内容

    

    
‘t'
以文本模式操作文件内容

    

    
‘+'
可以同时读写某个文件

    
    

    


    1.r只读模式
    r: read，只读模式，只能读不能写，文件不存在时报错。
    

    

    f = open(r'test.py', 'rt', encoding='utf8')
f.write('slkdjfklj')
data = f.read()
print(data)
print(f.readable()) # 判断是否可读 true
print(f.writable()) # 判断是否可写 false
    

    

    

    2.w 只些模式（清空写入）
    

    w: 只能写，不能读，文件存在的时候回清空文件后再写入内容；文件不存在的时候会创建文件后写入内容。
    

    

    f = open(r'test.py', 'wt', encoding='utf8')
print(f.readable())  # false
print(f.writable())  # true
    

    

    

    3.a只写模式（追加写入）
    

    

    a: 可以追加。文件存在，则在文件的末端写入内容；文件不存在的时候会创建文件后写入内容。
    

    

    f = open(r'test.py', 'at', encoding='utf8')
print(f.readable())  # false
print(f.writable())  # true
    

    

     
    

    文件的两种读取格式
    

    

      

    1. 

      b模式 文件打开读取二进制
      

      b模式是通用的模式，因为所有的文件在硬盘中都是以二进制的形式存储的，需要注意的是：b模式读写文件，一定不能加上encoding参数，因为二进制无法再编码。
      

      b模式常用于爬虫或是音频、图片、视频的保存
      

      2. 

    2. 

      t模式 打开TXT类型文件
      

      t模式可以和r、w、a连用，rt、wt、at指的都是操作文本文件。一般默认的读写内容的模式为t模式
      

      3. 

    

    

    绝对路径和相对路径
    

    

      

    1. 

      绝对路径
      

        

      • Windows系统绝对路径从盘符（C:、D:）开始写一个完整的路径。
        • 

      • macos系统从根目录(/Users)开始写一个完整的路径。
        • 

      

      2. 

    2. 

      相对路径
      

      相对于当前执行文件所在的文件夹开始找。
      

      f = open('test.txt') # test.txt与py文件同路径位置, 可直接写文件名
      

      3. 

    

    

    with管理上下文
    

    

    之前用open()方式打开文件,还需要手动将文件关闭 释放占用内存, 更简单方便的就是with open()
    

    

    with open()方法不仅提供自动释放操作系统占用的方法，并且with open可以使用逗号分隔，一次性打开多个文件，实现文件的快速拷贝。
    

    

    # 两种写法
# with open('32.txt', 'rb') as fr, open('35r.txt', 'wb') as fw:

with open('32.txt', 'rb') as fr,    #斜杠表示换行
        open('35r.txt', 'wb') as fw:
    f.write(f.read())
    

    

    文件的高级应用
    

    可读、可写
    

    r+t: 可读、可写
    

    

    # 可简写为r+
with open('36w.txt', 'r+', encoding='utf-8') as fr:
    print(fr.readable()) # true
    print(fr.writable()) # true
    

    

    w+t: 可写、可读
    

    

    # 可简写为w+
with open('36w.txt', 'w+', encoding='utf-8') as fw:
    print(fw.readable()) # true
    print(fw.writable()) # true
    

    

    a+t: 可追加、可读
    

    

    # 可简写为a+
with open('36w.txt', 'a+', encoding='utf-8') as fa:
    print(fa.readable()) # true
    print(fa.writable()) # true
    

    

    文件内指针移动
    

    在utf8编码中,8个进制位为一个字节,3个8进制位组成一个字符(针对中文,英文是一个字节一个字符)
    

      

    • 

      read(n): 只有在t模式下的read(n)，n代表的是字符个数，除此之外，其他但凡涉及文件指针的都是字节个数
      

      with open('36r.txt', 'rt', encoding='utf-8') as fr:
    print(f"fr.read(3): {fr.read(3)}")
      

      • 

    • 

      seek(offset,whence): offset代表文件指针的偏移量，偏移量的单位是字节个数
      

      with open('1.txt', 'rb') as fr:
    print(f"fr.seek(4, 0): {fr.seek(4, 0)}")  # 0相当于文件头开始；1相当于当前文件所在位置；2相当于文件末尾
    # fr.seek(0,2)  # 切换到文件末尾
      

      • 

    • 

      tell(): 每次统计都是从文件开头到当前指针所在位置
      

      with open('36r.txt', 'rb') as fr:
    fr.seek(4, 0)
    print(f"fr.tell(): {fr.tell()}")
      

      • 

    • 

      truncate(n): truncate(n)是截断文件，所以文件的打开方式必须可写，但是不能用w或w+等方式打开，因为那样直接清空文件了，所以truncate()要在r+或a或a+等模式下测试效果。它的参照物永远是文件头。并且truncate()不加参数，相当于清空文件。
      

      with open('36r.txt', 'ab') as fr:
    fr.truncate(2) # 截断2个字节后的所有字符，如果3个字节一个字符，只能截断2/3个字符，还会遗留1/3个字符，会造成乱码
      

      • 

    

    登陆注册：
    

    

    # # 注册
#
count = 0
while count < 3:
    username_inp = input('请输入你的用户名:')
    pwd_inp = input('请输入你的密码:')
    re_pwd_inp = input('请在此输入你的密码:')

    if not pwd_inp == re_pwd_inp:
        print('两次密码输入不一致')
        count += 1
        continue

    with open('user_info.txt', 'a', encoding='utf8') as fa:
        fa.write(f'{username_inp}:{pwd_inp}
')  # :表示用户名和密码的分割;|用户和用户之间的分割
        fa.flush()
        break

# 登录
username_inp = input('请输入你的用户名:')
pwd_inp = input('请输入你的密码:')

with open('user_info.txt', 'r', encoding='utf8') as fr:
    for user_info in fr:
        username, pwd = user_info.split(':')

        if username.strip() == username_inp and pwd.strip() == pwd_inp:  # strip可以去掉两端的换行符
            print('登录成功')
            break
        # else:
        #     continue  # continue一般不写在最后一行
    else:
        print('登录失败')
    

    

    

    文件修改的两种方式
    

    硬盘上从来没有修改一说，硬盘上只有覆盖，即新内容覆盖新内容。
    

    修改文件内容的思路为：以读的方式打开原文件，以写的方式打开一个新的文件，把原文件的内容进行修改，然后写入新文件，之后利用os模块的方法，把原文件删除，重命名新文件为原文件名，达到以假乱真的目的。
    

    方式一
    

    将硬盘存放的该文件的内容全部加载到内存，在内存中是可以修改的，修改完毕后，再由内存覆盖到硬盘（word，vim，nodpad++等编辑器）
    

    

    

    import os

with open('37r.txt') as fr, 
        open('37r_swap.txt', 'w') as fw:
    data = fr.read()  # 全部读入内存,如果文件很大,会很卡
    data = data.replace('tank', 'tankSB')  # 在内存中完成修改

    fw.write(data)  # 新文件一次性写入原文件内容

# 删除原文件
os.remove('37r.txt')
# 重命名新文件名为原文件名
os.rename('37r_swap.txt', '37r.txt')
print('done...')
    

    

    

    方式二
    

    将硬盘存放的该文件的内容一行一行地读入内存，修改完毕就写入新文件，最后用新文件覆盖源文件。
    

    

    import os

with open('37r.txt') as fr,
        open('37r_swap.txt', 'w') as fw:
    # 循环读取文件内容，逐行修改
    for line in fr:
        line = line.replace('jason', 'jasonSB')
        # 新文件写入原文件修改后内容
        fw.write(line)

os.remove('37r.txt')
os.rename('37r_swap.txt', '37r.txt')
print('done...')
    

    


    

    

    

    
    
                
    
                
              
    • 
              
    
              
  • 

                相关阅读:
    
                
                  面经
                    
    Onedrive云盘程序——OneManager小白设置指南
                    
    Docker 命令
                    
    Linux 命令 
                    
    Spring boot 返回参数移除null属性
                    
    Springboot
                    
    正则
                    
    JVM内存模型
                    
    缓冲和缓存的区别
                    
    SpringBoot如何优雅的将静态资源配置注入到工具类中
                    
                        
              
    • 
              
    
              
  • 
                原文地址：https://www.cnblogs.com/fjn839199790/p/11620729.html
              
    • 

            

          



          
          

            

            

          

        

      

      



      

      

        

          Copyright © 2011-2022 走看看