您的位置:新葡亰496net > 奥门新萄京娱乐场 > 新葡亰496net:文本操作,python全栈开荒

新葡亰496net:文本操作,python全栈开荒

发布时间:2019-11-15 12:45编辑:奥门新萄京娱乐场浏览(85)

     

    python_day8

    大器晚成.明天首要内容
    文件操作:

    1. r
    2. w
    3. a
    4. r 读写情势.要求活动光标进行数次读写

    5. w

    6. a
    7. b bytes 读写操作的是字节. 用在非文本上
    8. seek() 移动光标到xx地方,开端: seek(0), 末尾: seek(0,2)
    9. 文本改善

      创造新文件. 把修改后的源委写入新文件. 删除老文件. 重命名新文件
      import os
      os.remove("")删除文件
      os.rename("源文件", "新文件名") 重命名文件

      for line in f:
      line 风流罗曼蒂克行数据

      with open("文件名") as f:
      无需关闭文件句柄

    08. 万恶之源-⽂件操作
    本节关键内容:

    1. 初识⽂件操作
    2. 只读(r, rb)
    3. 只写(w, wb)
    4. 追加(a, ab)
    5. r 读写
    6. w 写读
    7. a 写读(追加写读)
    8. 此外操作⽅法
    9. ⽂件的纠正以至另⼀种张开⽂件句柄的⽅式

    珍视内容:
    ⼀. 初识⽂件操作
    使⽤python来读写⽂件是超轻便的操作. 大家使⽤open()函数来展开⼀个⽂件, 获取到⽂
    件句柄. 然后经过⽂件句柄就足以进⾏有滋有味的操作了. 根据展开⽅式的例外亦可执⾏的操
    作也是有照望的差距.
    打开⽂件的⽅式: r, w, a, r , w , a , rb, wb, ab, r b, w b, a b 默认使⽤的是r(只读)模式
    ⼆. 只读操作(r, rb)

    f = open("护⼠少妇嫩模.txt",mode="r", encoding="utf-8")
    content = f.read()
    print(content)
    f.close()
    

    亟需注意encoding表⽰编码集. 依据⽂件的实在保存编码进⾏获取数据, 对于大家⽽⾔. 更 多的是utf-8.

    rb. 读收取来的数据是bytes类型, 在rb情势下. 不可能接受encoding字符集.

    f = open("护⼠少妇嫩模.txt",mode="rb" )
    content = f.read()
    print(content)
    f.close()
    #结果:
    b'xe6xafx85xe5x93xa5, xe5xa4xaaxe7x99xbd,
    wusenxe5x91xb5xe5x91xb5nxe6x97xa5xe5xa4xa9'
    

    rb的作⽤:

    在读取非⽂本⽂件的时候. 比方读取VCD. 图像. 录制等新闻的时候就供给⽤到 rb. 因为这种数据是没

    主意间接显⽰出来的. 在后⾯我们⽂件上传下载的时候还有恐怕会⽤到. 还也是有. 大家看的直播. 实际上都以那

    种数据. 相对路线和相对路线: 1. 相对路线:从磁盘根⽬录伊始⼀直到⽂件名. 2. 相对路线:同⼀个⽂件

    夹下的⽂件. 相对于当下以此顺序所在的⽂件夹⽽⾔. 假若在同 ⼀个⽂件夹中. 则相对路线正是以此⽂

    件名. 借使在上⼀层⽂件夹. 则要../

    新葡亰496net 1

    更推荐⼤家使⽤相对路径. 因为在我们把程序拷⻉给别⼈使⽤的时候. 直接把项⽬拷⻉走 就能够运⾏. 可是即使⽤相对路径. 那还亟需拷⻉外界的⽂件.

    **本节重要内容:

    1.文书操作

      使用python来读写文件是特别简单的的操作,大家选取open()函数来开荒一个文书,获取到文件句柄,然后经过文件家居并就足以进行丰富多彩的操作了。遵照打开药情势的两样亦可实行的操作也是有照料的反差。

      张开的 情势:r,w,a,r ,w ,a ,rb,wb,ab,r b,w b,ab.暗许使用的是r(只读卡塔 尔(阿拉伯语:قطر‎格局

    生龙活虎丶文件基本操作

    读取⽂件的⽅法: 1. read() 将⽂件中的内容全方位读抽取来. 缺欠: 占内部存款和储蓄器. 假设⽂件过⼤.轻便引致内部存款和储蓄器崩溃

    f = open("../def/哇擦.txt", mode="r", encoding="utf-8")
    content = f.read()
    print(content)
    #结果:
    友谊地久天⻓,
    爱⼀点,
    可惜我是⽔瓶座
    ⼀⽣中最爱
    
    1. 初识⽂件操作
    2. 只读(r, rb)
    3. 只写(w, wb)
    4. 追加(a, ab)
    5. r 读写
    6. w 写读
    7. a 写读(追加写读)
    8. 别的操作⽅法
    9. ⽂件的改变以至另⼀种张开⽂件句柄的⽅式**

    2.只读操作(r,rb卡塔 尔(阿拉伯语:قطر‎

    1 f = open("a.txt",mode = "r",encoding = "utf-8")
    2 content = f.read()
    3 print(content)
    4 f.close()
    

    encoding代表编码集,越来越多选取utf-8

      rb读收取来的数码是bytes类型,在rb形式下,不可能选取encoding字符集

    1 f = open("a.txt",mode = "rb")
    2 content = f.read()
    3 print(content)
    4 f.close
    

      rb的效益:在读取非文本文件的时候,譬喻读取MP5,图像,录制等新闻的时候就须要用到rb,因为这种数量是不能直接显示出来的,在前面大家文件上传下载的时候还有大概会用到,还应该有看的直播,都以这种数据。

     

    相对路径和相对路径:

    1.相对路线:从磁盘根目录最早一贯到文件名

    2.相对路径:同叁个文件夹下的文件,相对于近些日子那一个程序所在的文书夹来讲,假诺在同贰个文本夹中,则相对路径正是这些文件名,要是在上生龙活虎层文件夹,则要加../

    推荐介绍使用相对路线,因为在把程序拷贝给外人利用的时候,直接把品种拷贝走就能够运转,但是倘若利用相对路线,还亟需拷贝外部的公文。

     

    读取文件的办法:

      read(卡塔 尔(阿拉伯语:قطر‎将文件中的内容全方位读抽出来,缺陷:占内部存款和储蓄器,倘若文件过大,轻易招致内部存款和储蓄器崩溃

    1 f = open("a.txt",mode = "r",encoding = "utf-8")
    2 content = f.read()
    3 print(content)
    

      read(n)读取n个字符,须求专一的是,若是重新读取,那么会在脚无业位三回九转去读并非从头去读,假若使用的是rb方式,则读抽出来的是n个字节

      

    1 f = open("a.txt",mode = "r",encoding = "utf-8")
    2 content1 = f.read(3)
    3 content2 = f.read(3)
    4 print(content1)
    5 print(content2)
    

      readline()一次读取后生可畏行数据,注意:readline()结尾,注意每便读收取来的数据都会有二个n,所以需求运用strip()方法来去掉n可能空格

     1 f = open("a.txt",mode = "r",encoding="utf-8")
     2 content1 = f.readline()
     3 content2 = f.readline()
     4 content3 = f.readline()
     5 content4 = f.readline()
     6 print(content1)
     7 print(content2)
     8 print(content3)
     9 print(content4)
    10 f.close
    

       readlines()将每风流浪漫行产生三个因素,放到二个列表中。将有着的故事情节都读抽出来,所哟也是便于并发内存崩溃的主题材料,不推荐使用。

    1 f = open("a.txt",mode = "r",encoding = "utf-8")
    2 lst = f.readlines()
    3 print(lst)
    4 for line in lst:
    5     print(line.strip())
    

      循环读取。这种方法是最佳的,每便读取生机勃勃行,不会爆发内部存款和储蓄器溢出的主题素材

      

    1 f = open("a.txt",mode = "r",encoding = "utf-8")
    2 for line in f:
    3     print(line.strip())
    

      读取完的文书句柄必定要关闭 f.close()

      1.开垦文件

    2. read(n) 读取n个字符. 供给注意的是. 假如重新读取. 那么会在这几天职责延续去读⽽不 是从头读, 假设使⽤的是rb情势. 则读收取来的是n个字节

    f = open("../def/哇擦.txt", mode="r" encoding="utf-8")
    content = f.read(3)
    print(content)
    #结果:
    友谊地
    f = open("../def/哇擦.txt", mode="rb")
    content = f.read(3)
    print(content)
    #结果:
    b'xe5x8fx8b'
    f = open("../def/哇擦.txt", mode="r", encoding="utf-8")
    content = f.read(3)
    content2 = f.read(3)
    print(content)
    print(content2)
    #结果:
    友谊地
    久天⻓
    

    器重内容:
    ⼀. 初识⽂件操作
    使⽤python来读写⽂件是⾮常简单的操作. 大家使⽤open()函数来打开⼀个⽂件, 获取到⽂
    件句柄. 然后经过⽂件句柄就足以进⾏丰富多彩的操作了. 根据伸开⽅式的两样亦可执⾏的操
    作也许有相应的差距.
    打开⽂件的⽅式: r, w, a, r , w , a , rb, wb, ab, r b, w b, a b 默认使⽤的是r(只读)模式

    3.写模式(w,wb)

    写的时候,若无公文,则会创立文件,假使文件存在,则将原来的书文件中原来的原委删除,再写入新的内容

      

    1 f = open("a.txt",mode = "w",encoding="utf-8")
    2 f.write("123")
    3 f.flush()
    4 f,close()
    

    wb情势下,能够不钦定展开文件的编码,不过在写文件的时候必得将字符串转产生utf-8的bytes数据

        open(文件名(路径),mode = "?",encoding = "字符集")

    3. readline() ⼀次读取⼀⾏数据, 注意: readline()结尾, 注意每一遍读收取来的多寡都会有⼀ 个n 所以呢. 必要我们使⽤strip()⽅法来去掉n或许空格

    f = open("../def/哇擦.txt", mode="r", encoding="utf-8")
    content = f.readline()
    content2 = f.readline()
    content3 = f.readline()
    content4 = f.readline()
    content5 = f.readline()
    content6 = f.readline()
    print(content)
    print(content2)
    print(content3)
    print(content4)
    print(content5)
    print(content6)
    #结果:
    友谊地久天⻓,
    爱⼀点,
    可惜我是⽔瓶座
    ⼀⽣中最爱
    

    ⼆. 只读操作(r, rb)

    4.追加(a,ab)

    在增多情势下,写入的内容会增添在文书的最后

    新葡亰496net,  2.文件路线:

    4. readlines()将每⼀⾏形成⼀个要素, 放到⼀个列表中. 将具有的从头到尾的经过都读抽取来. 所以 也是. 轻巧现身内部存款和储蓄器崩溃的难点.不引入使⽤

    f = open("../def/哇擦.txt", mode="r", encoding="utf-8")
    lst = f.readlines()
    print(lst)
    for line in lst:
     print(line.strip())
    

    新葡亰496net 2

    5.读写形式(r ,r b卡塔 尔(英语:State of Qatar)

      对于读写格局,必需是先读,因为暗中认可光标是在上马考虑读取的,当读完了后来再开展写入

      

    1 f = open("a.txt",mode = "r ",encoding = "utf-8")
    2 cotent = f.read()
    3 f.write("123")
    4 print(content)
    5 f.flush()
    6 f.close()
    

    新葡亰496net:文本操作,python全栈开荒。  必得在读取之后再写

        1.相对路径,从磁盘的根目录搜索,或许从互联互连网搜寻三个路线

          

    f = open("e:/abc/里皮.txt",mode = "r".encoding = "gbk")
    s = f.read()
    print(s)
    f.close()
    

     

    5. 周而复始读取. 这种⽅式是组好的. 每回读取⼀⾏内容.不会产⽣内部存储器溢出的难点.

    f = open("../def/哇擦.txt", mode="r", encoding="utf-8")
    for line in f:
     print(line.strip())
    

    留心: 读取完的⽂件句柄⼀定要关闭 f.close() 三. 写情势(w, wb) 写的时候注意. 若无⽂件. 则会创制⽂件,

    设若⽂件存在. 则将原件中本来的内容剔除, 再 写入新内容.

    f = open("⼩娃娃", mode="w", encoding="utf-8")
    f.write("⾦⽑狮王")
    f.flush() # 刷新. 养成好习惯
    f.close()
    

    尝试读⼀读

    f = open("⼩娃娃", mode="w", encoding="utf-8")
    f.write("⾦⽑狮王")
    f.read() # not readable 模式是w. 不可以执⾏读操作
    f.flush()
    f.close()
    

    wb格局下. 能够不内定展开⽂件的编码. 不过在写⽂件的时候必得将字符串转变成utf-8的 bytes数据

    f = open("⼩娃娃", mode="wb")
    f.write("⾦⽑狮王".encode("utf-8"))
    f.flush()
    f.close()
    

    新葡亰496net 3

    6.写读方式(w ,w b卡塔 尔(阿拉伯语:قطر‎

      先将兼具剧情清空,然后写入,最终读取,可是读取的故事情节是空的,临时用

        2.相对路线,相对于当下程序所在的文件夹

    ../ 返回上一级
    f = open("../abc/晓峰",mode = "r",encoding="gbk")
    s = f.read()
    print(s)
    f.close()
    

    四. 追加(a, ab)

    在大增格局下. 大家写入的开始和结果会大增在⽂件的结尾.

    f = open("⼩娃娃", mode="a", encoding="utf-8")
    f.write("麻花藤的最爱")
    f.flush()
    f.close()
    

    ab情势⾃⼰试⼀试就好了

    **相对路线和相对路线:

    7.追加读(a )

      a 方式下,无论是先读照旧后读,都以读取不到多少的.

      3.创办新文件. 把改良后的源委写入新文件. 删除老文件. 重命名新文件

    import os
    os.remove("")删除文件
    os.rename("源文件", "新文件名") 重命名文件
    
    for line in f:
    line 一行数据
    
    with open("文件名") as f:
    不需要关闭文件句柄
    

     

    五. 读写格局(r , r b)

    对此读写方式. 必得是先读. 因为暗许光标是在领头的. 筹算读取的.

    当读完通晓后再进⾏ 写入. 大家随后使⽤频率最⾼的情势就是r 精确操作是:

    f = open("⼩娃娃", mode="r ", encoding="utf-8")
    content = f.read()
    f.write("麻花藤的最爱")
    print(content)
    f.flush()
    f.close()
    #结果:
    #正常的读取之后, 写在结尾
    

    错误操作:

    f = open("⼩娃娃", mode="r ", encoding="utf-8")
    f.write("哈哈")
    content = f.read()
    print(content)
    f.flush()
    f.close()
    

    结果: 将初叶的始末改写成了"哈哈", 然后读取的内容是后⾯的内容.

    就此记住: r 模式下. 必需是先读取. 然后再写入 六. 写读(w , w b) 先将全数的内容清空. 然后写入. 最后读取. 但是读取的剧情是空的, 不常⽤

    f = open("⼩娃娃", mode="w ", encoding="utf-8")
    f.write("哈哈")
    content = f.read()
    print(content)
    f.flush()
    f.close()
    

    有⼈会说. 先读不就好了么? 错. w 方式下, ⼀开首读取不到数据. 然后写的时候再将原先 的剧情清空. 所以, 非常少⽤.

    1. 相对路线:从磁盘根⽬录最早⼀直到⽂件名.
    2. 相对路线:同⼀个⽂件夹下的⽂件. 相对于当下以此顺序所在的⽂件夹⽽⾔. 假设在同
      ⼀个⽂件夹中. 则绝对路线正是其风流洒脱⽂件名. 假若在上⼀层⽂件夹. 则要../ **

    8.其余相关操作

      1.seek(n) 光标移动到n地点,移动的单位是byte,所犹假诺是utf-8的汉语部分借使3的翻番

        移动到最先:seek(0)

        移动到最终:seek(0,2) seek的第1个参数表示的是从哪个岗位打开偏移,默许是0,表示起先,1代表近些日子岗位,2意味着最后

      2.tell()  使用tell()能够帮大家收获到近年来光标在什么样职位

      3.truncate()  截断文件 

        在r 格局下,借使读取了内容,不论读取多少,光标突显的是微微,再写入可能操作文件的时候都以在终极实行的操作。

        如若想做截断操作,要先挪动光标到想截断的职位,然后再实行截断

        尽管truncate(n) 给出了n,则从早先实行截断,纵然不给n,则从前段时间岗位截断,前面包车型地铁从头到尾的经过将会被去除

      4.  退换文件甚至另大器晚成种张开文件的法子

          文件改革:只好将文件中的内容读取到内部存款和储蓄器中,将消息改进实现,然后将源文件删除,将新的文件的名字改成老文件的名字

        

    1 import os
    2 
    3 with open("a.txt",mode = "r",encoding = "utf-8") as f1,
    4     open("a1.txt",mode = "w",encoding = "utf-8") as f2:
    5     content = f1.read()
    6     content1 = content1.replace("456","123")
    7     f2.write(content1)
    8 os.remove("a.txt")
    9 os.rename("a1.txt","a.txt")
    

    壹次将具有的内存读取,内部存款和储蓄器溢出

    减轻方案:大器晚成行业作风流罗曼蒂克行的读取和操作

     

    二丶文件操作

    七. 追加读

    (a ) a 形式下, 无论先读依旧后读. 都以读取不到数码的.

    f = open("⼩娃娃", mode="a ", encoding="utf-8")
    f.write("⻢化腾")
    content = f.read()
    print(content)
    f.flush()
    f.close()
    

    还会有⼀些别的的带b的操作. 就异常少废话了. 正是把字符换来字节. 仅此⽽已

     读取文件的秘籍:

      1.初识文件操作

    八. 别的相关操作

    1. seek(n) 光标移动到n地点, 注意, 移动的单位是byte. 所以如若是UTF-8的中⽂部分要 是3的倍数.

    日常来讲我们使⽤seek都以运动到早先大概结尾. 移动到初阶: seek(0) 移动到终极: seek(0,2) seek的第⼆个参数表⽰的是

    从哪些岗位进⾏偏移, 暗中同意是0, 表 ⽰初始, 1表⽰当前岗位, 2表⽰结尾

    f = open("⼩娃娃", mode="r ", encoding="utf-8")
    f.seek(0) # 光标移动到开头
    content = f.read() # 读取内容, 此时光标移动到结尾
    print(content)
    f.seek(0) # 再次将光标移动到开头
    f.seek(0, 2) # 将光标移动到结尾
    content2 = f.read() # 读取内容. 什么都没有
    print(content2)
    f.seek(0) # 移动到开头
    f.write("张国荣") # 写⼊信息. 此时光标在9 中⽂3 * 3个 = 9
    f.flush()
    f.close()
    

    f.read(n)   n--->>>>n个字符  如果是rb,则n指字节

        1.行使python来读写文件是特别不难的操作,大家运用open()函数来开荒多少个文本,获取到文件句柄,然后经过文件句柄就能够举办五种种种的操作了,依据打开药格局的不等亦可奉行的操作也是有对应的出入

    2. tell() 使⽤tell()能够帮大家取获得当前光标在怎么样地方

    f = open("⼩娃娃", mode="r ", encoding="utf-8")
    f.seek(0) # 光标移动到开头
    content = f.read() # 读取内容, 此时光标移动到结尾
    print(content)
    f.seek(0) # 再次将光标移动到开头
    f.seek(0, 2) # 将光标移动到结尾
    content2 = f.read() # 读取内容. 什么都没有
    print(content2)
    f.seek(0) # 移动到开头
    f.write("张国荣") # 写⼊信息. 此时光标在9 中⽂3 * 3个 = 9
    print(f.tell()) # 光标位置9
    f.flush()
    f.close()
    

     将文件全部读抽取来,缺欠是,占内存,假若文件过大,会变成内部存款和储蓄器崩溃.

        2.开发布文书件的章程:r(只读),w(只写),a(追加),r (读写),w (写读),a (追加写读),rb(只读),wb(只写),ab(追加),r b,w b,a b默许使用的是r(只读方式)

    3. truncate() 截断⽂件

    f = open("⼩娃娃", mode="w", encoding="utf-8")
    f.write("哈哈") # 写⼊两个字符
    f.seek(3) # 光标移动到3, 也就是两个字中间
    f.truncate() # 删掉光标后⾯的所有内容
    f.close()
    f = open("⼩娃娃", mode="r ", encoding="utf-8")
    content = f.read(3) # 读取12个字符
    f.seek(4)
    print(f.tell())
    f.truncate() # 后⾯的所有内容全部都删掉
    # print(content)
    f.flush()
    f.close()
    

    深坑请小心: 在r 格局下. 假诺读取了内容. 无论读取内容有一些. 光标显⽰的是有一点点. 再写入 也许操作⽂件的时候都是

    在最后进⾏的操作.

    所以即使想做截断操作. 记住了. 要先挪动光标. 挪动到你想要截断的地点. 然后再进⾏截断 关于truncate(n), 借使给

    出了n. 则从开始早先进⾏截断, 如若不给n, 则从脚无业位截断. 后⾯ 的情节将会被剔除

     

     f.readline()    意气风发行生龙活虎行的读,可是读出来的结尾会有叁个n,必要我们用strip()去掉

      2.只读操作(r,rb)

    九. 修正⽂件以至另⼀种打开⽂件的⽅式

    ⽂件订正: 只可以将⽂件中的内容读取到内部存储器中, 将音信改进实现, 然后将源⽂件删除, 将新 ⽂件的名字改成老⽂件的名字.

    # ⽂件修改
    import os
    with open("⼩娃娃", mode="r", encoding="utf-8") as f1,
     open("⼩娃娃_new", mode="w", encoding="UTF-8") as f2:
     content = f1.read()
     new_content = content.replace("冰糖葫芦", "⼤⽩梨")
     f2.write(new_content)
    os.remove("⼩娃娃") # 删除源⽂件
    os.rename("⼩娃娃_new", "⼩娃娃") # 重命名新⽂件
    

    弊病: ⼀次将有所内容进⾏读取. 内部存款和储蓄器溢出. 消除⽅案: ⼀⾏⼀⾏的读取和操作

    import os
    with open("⼩娃娃", mode="r", encoding="utf-8") as f1,
     open("⼩娃娃_new", mode="w", encoding="UTF-8") as f2:
     for line in f1:
     new_line = line.replace("⼤⽩梨", "冰糖葫芦")
     f2.write(new_line)
    os.remove("⼩娃娃") # 删除源⽂件
    os.rename("⼩娃娃_new", "⼩娃娃") # 重命名新⽂件
    

    2018-07-11  15:37:55

     作业:

    一,有如下文件,a1.txt,里面的内容为:
    老男孩是最好的培训机构,
    全心全意为学生服务,
    只为学生未来,不为牟利。
    我说的都是真的。哈哈
    分别完成以下的功能:
    a,将原文件全部读出来并打印。
    
    f = open("a1.txt",mode="r",encoding="utf-8")
    s = f.read()
    print(s)
    f.flush()
    f.close()
    
    b,在原文件后面追加一行内容:信不信由你,反正我信了。
    
     = open('a1.txt',mode="a",encoding="utf-8")
    f.write("n信不信由你,反正我信了")
    f.flush()
    f.close()
    
    c,将原文件全部读出来,并在后面添加一行内容:信不信由你,反正我信了。
    
    = open("a1.txt",mode="r ",encoding="utf-8")
    s = f.read()
    print(s)
    f.write("n信不信由你,反正我信了")
    f.flush()
    f.close
    
    d,将原文件全部清空,换成下面的内容:
    
    每天坚持一点,
    每天努力一点,
    每天多思考一点,
    慢慢你会发现,
    你的进步越来越大。
    
    f =  open("a1.txt",mode="w",encoding="utf-8")
    f.write("每天坚持一点,n每天努力一点,n每天多思考一点,n慢慢你会发现,n你的进步越来越大")
    f.flush()
    f.close()
    
    e,将原文件内容全部读取出来,并在‘我说的都是真的。哈哈’这一行的前面加一行,
    ‘你们就信吧~’然后将更改之后的新内容,写入到一个新文件:a1.txt。
    
    import os
    with open("a1.txt",mode="r ",encoding="utf-8")as f,
        open("a1_1.txt",mode="w",encoding="utf-8")as f1:
        for line in f:
            f1.write(line.replace("我说的都是真的。哈哈","你们就信吧~n我说的都是真的。哈哈"))
    os.remove("a1.txt")
    os.rename("a1_1.txt","a1.txt")
    
    二,有如下文件,t1.txt,里面的内容为:
    葫芦娃,葫芦娃,
    一根藤上七个瓜
    风吹雨打,都不怕,
    啦啦啦啦。
    我可以算命,而且算的特别准:
    上面的内容你肯定是心里默唱出来的,对不对?哈哈
    分别完成下面的功能:
    a,以r 的模式打开原文件,判断原文件是否可读,是否可写。
    
    f = open("t1.txt",mode="r ",encoding="utf-8")
    print(f.readable())
    print(f.writable())
    f.close()
    
    b,以r的模式打开原文件,利用for循环遍历文件句柄。
    
    f = open("t1.txt",mode='r',encoding='utf-8')
    for line in f:
        print(line,end="")
    
    c,以r的模式打开原文件,以readlines()方法读取出来,并循环遍历
    readlines(),并分析b,与c 有什么区别?深入理解文件句柄与
    readlines()结果的区别。
    
    f = open("t1.txt",mode='r',encoding="utf-8")
    lst = f.readlines()
    for i in lst:
        print(i,end="")
    
    d,以r模式读取‘葫芦娃,’前四个字符。
    
    f = open("t1.txt",mode="r",encoding='utf-8')
    s = f.read(4)
    print(s)
    f.flush()
    f.close()
    
    e,以r模式读取第一行内容,并去除此行前后的空格,制表符,换行符。
    
    f = open("t1.txt",mode='r',encoding="utf-8")
    s = f.readline()
    print(s.strip())
    
    f,以r模式打开文件,从‘风吹雨打.....’开始读取,一直读到最后。
    
    f = open("t1.txt",mode="r",encoding='utf-8')
    for i in f:
        if i.startswith("风吹雨打"):
            print(i,end='')
            print(f.read())
    f.flush()
    f.close()
    
    g,以a 模式打开文件,先追加一行:‘老男孩教育’然后在从最开始将原内容全部读取出来。
    
    f = open("t1.txt",mode="a ",encoding="utf-8")
    f.write("n老男孩教育")
    f.seek(0)
    s = f.read()
    print(s)
    f.flush()
    f.close()
    
    h,截取原文件,截取内容:‘葫芦娃,葫芦娃,’
    
    f = open("t1.txt",mode="r ",encoding='utf-8')
    f.seek(24)
    f.truncate()
    f.seek(0)
    s = f.read()
    print(s)
    f.close()
    
    三,文件a.txt内容:每一行内容分别为商品名字,价钱,个数。
    
    apple 10 3
    tesla 100000 1
    mac 3000 2
    lenovo 30000 3
    chicken 10 3
    通过代码,将其构建成这种数据类型:
    [{'name':'apple','price':10,'amount':3},{'name':'tesla','price':1000000,'amount':1}......]
    并计算出总价钱。
    
    li = []
    sum = 0
    f = open("a.txt",mode="r",encoding="utf-8")
    lst = f.readlines()
    for i in lst:
        dic = {}
        s = i.strip().split(" ")
        dic['name'] = s[0]
        dic['price'] = s[1]
        dic['amount'] = s[2]
        sum = sum   int(dic["price"])
        li.append(dic)
    print(li)
    print(sum)
    
    四,有如下文件:
    
    alex是老男孩python发起人,创建人。
    alex其实是人妖。
    谁说alex是sb?
    你们真逗,alex再牛逼,也掩饰不住资深屌丝的气质。
    
    将文件中所有的alex都替换成大写的SB(文件的改的操作)。
    
    import os
    with open("alex.txt",mode="r",encoding="utf-8")as f,
        open("alex_1.txt",mode="w",encoding="utf-8")as f1:
        for line in f:
            s = line.replace("alex","SB")
            f1.write(s)
    os.remove("alex.txt")
    os.rename("alex_1.txt","alex.txt")
    
    五.文件a1.txt内容(升级题)
    name:apple price:10 amount:3 year:2012
    name:tesla price:100000 amount:1 year:2013
    .......
    通过代码,将其构建成这种数据类型:
    [{'name':'apple','price':10,'amount':3},
    {'name':'tesla','price':1000000,'amount':1}......]
    并计算出总价钱。
    
    lis = []
    dic = {}
    sum = 0
    with open('a2.txt',mode="r",encoding='utf-8') as f:
        for i in f.readlines():
            c = i.split('n')[0].split()
            for j in c:
                dic[j.split(':')[0]] = j.split(':')[1]
            sum  = int(dic['price']) * int(dic['amount'])
            lis.append(dic)
    print(lis)
    print(sum)
    
    六.文件a1.txt内容(升级题)
    序号     部门      人数      平均年龄      备注
    1       python    30         26         单身狗
    2       Linux     26         30         没对象
    3       运营部     20         24         女生多
    .......
    通过代码,将其构建成这种数据类型:
    [{'序号':'1','部门':Python,'人数':30,'平均年龄':26,'备注':'单身狗'},
    ......]
    
    lis = []
    with open('a3.txt',mode="r",encoding='utf-8') as f:
        s = f.readline().split()
        for i in f.readlines():
            dic = {}
            c = i.split()
            for j in range(len(c)):
                dic[s[j]] = c[j]
            lis.append(dic)
    print(lis)
    

     

     新葡亰496net 4

      r:

    f = open("小护士.txt",mode="r",encoding="utf-8")   #打开小护士.txt文件   编码集为utf-8
    content = f.read()   #只读
    print(content)
    f.close     #关闭
    

    瞩目:  读取完的文本句柄应当要关闭    f.close()

      rb:

    f = open("小护士.txt",mode="rb")
    content = f.read()
    print(content)
    f.close
    
    结果:
    b'xe4xbdxa0xe6x98xafxe4xb8xaaxe5x82xbbxe5xadx90xe5x90x97?'
    

     

    三. 写模式(w, wb)
    写的时候注意. 如果未有⽂件. 则会成立⽂件, 假如⽂件存在. 则将原件中原来的原委剔除, 再
    写入新剧情

    rb的效用:在读取非文本文件的时候,比如读取MP5.图像.录像等新闻的时候就须要用到rb,因为这种数据是不可能直接展现出来的,在背后大家文件上传下载的时候还恐怕会用到,还会有大家看来的直播都是这种数据.

     

    新葡亰496net 5

       3.写模式(w,wb)

     

        写的时候注意,若无公文,则会创设文件,借使文件存在,则将原件中原来的源委剔除,再写入新内容

    f = open("小护士.txt",mode="rb")
    content = f.read()
    print(content)
    f.close
    
    
    f = open("小娃娃",mode="w",encoding="utf-8")
    f.write("金毛狮王")     #写入"金毛狮王"
    # f.read()    #模式是w ,不可执行读操作
    f.flush()       #刷新
    f.close()
    

     

     

     新葡亰496net 6

         wb格局下,能够不点名展开文件的编码,然而在写文件的时候必得将字符串转产生utf-8的bytes数据

    f = open("小娃娃",mode="wb")
    f.write("金毛狮王".encode("utf-8"))  #wb模式下,可以不指定打开文件的编码,但是在写文件的时候必须将字符串转化成utf-8的bytes数据
    f.flush()
    f.close()
    

    追加方式,a    写入的内容会加在结尾.

      4.追加(a,ab)

    五. 读写形式(r , r b)
    对于读写格局. 必需是先读. 因为暗中认可光标是在开始的. 准备读取的. 当读完了之后再进⾏
    写入. 大家之后使⽤频率最⾼的方式正是r

        追加形式下,大家写入的故事情节会增加在文书的最后

    f = open("小娃娃",mode="a",encoding="utf-8")
    f.write("麻花藤的最爱")
    f.flush()
    f.close()
    

     

    新葡亰496net 7

       5.读写方式(r ,r b)

     

        对于读写情势,必得是先读,因为暗中认可光标是在上马的,准备读取的,当读完了之后再开展写入

    f = open("小娃娃",mode="r ",encoding="utf-8")
    content = f.read()
    f.write("麻花藤的最爱")
    print(content)
    f.flush()
    f.close()
    

     还应该有写读(w ),追加读(a )等不时用,能够友善领会下

      6.写读(w ,w b)

    #先将所有的内容清空,然后写入最后读取,但是读取的内容是空的,不常用
    f = open("小娃娃",mode="w ",encoding="utf-8")
    f.write("哈哈")   #将哈哈写入
    content = f.read()      #已经被清空了
    print(content)
    f.flush()
    f.close()
    

     

      7.追加读(a )

    #a 模式下,不论先读还是后读,都是读取不到数据的
    f = open("小娃娃",mode="a ",encoding="utf-8")
    f.write("麻花藤")      #哈哈麻花藤
    content = f.read()
    print(content)
    f.flush()
    f.close()
    

     别的操作:

      8.读取文件的不二等秘书技:

    1. seek(n) 光标移动到n地点, 注意, 移动的单位是byte. 所以假设是UTF-8的中⽂部分要
    是3的倍数.
    万般大家使⽤seek都以活动到起来恐怕结尾.
    运动到开首: seek(0)
    一举手一投足到终极: seek(0,2) seek的第⼆个参数表⽰的是从哪个地点进⾏偏移, 暗中认可是0, 表
    ⽰最初, 1表⽰当前地方, 2表⽰结尾

        1.read()将文件的剧情全方位读抽取来,缺陷;占内部存款和储蓄器,倘若文件过大,轻巧产生崩溃

    f = open("哇卡.txt",mode="r",encoding = "utf-8")
    content = f.read()
    print(content)
    

    新葡亰496net 8

        2.read(n)读取n个字符,需求小心的是,假如重复读取,那么会在当下地点三番五次读并不是始于读,假设运用的是rb方式,则读收取来的是n个字节

    f = open("哇卡.txt",mode="r",encoding="utf-8")
    content = f.read(3)       #可以形
    print(content)
    

    2. tell() 使⽤tell()可以帮大家赢获得近日光标在怎样地方

        3.readline()一次读取风流浪漫行数据,注意:readline()结尾,注意每回读抽出来的数额都会有一个n,所以呢,供给大家应用strip()方法来去掉n只怕空格

    f = open("哇卡.txt",mode="r",encoding="utf-8")
    content = f.readline()
    content2 = f.readline()
    content3 = f.readline()
    content4 = f.readline()
    content5 = f.readline()
    content6 = f.readline()
    print(content)
    print(content2)
    print(content3)
    print(content4)
    print(content5)
    print(content6)
    

     呈现的是字节数,汉语正是3的翻番

        4.readlines()将每生龙活虎行形成三个因素,放到一个列表中,将有着的剧情都读抽出来,所以也是便于并发内部存储器崩溃的主题材料,不推荐使用

    f = open("哇卡.txt",mode="r",encoding="utf-8")
    lst = f.readline()
    print(lst)
    for line in lst:
        print(line.strip())
    

     3. truncate() 截断⽂件

        5.循环读取,这种措施是最棒的,每回读取风度翩翩行内容,不会生出内部存款和储蓄器溢出的主题素材

    f = open("哇卡.txt",mode="r",encoding="utf-8")
    for line in f:
        print(line.strip())
    

     

     

     新葡亰496net 9

    三丶别的相关操作

    深坑请细心: 在r 格局下. 假如读取了内容. 无论读取内容有一点点. 光标显⽰的是稍微. 再写入
    抑或操作⽂件的时候都以在最后进⾏的操作.
    于是即使想做截断操作. 记住了. 要先挪动光标. 挪动到你想要截断之处. 然后再进⾏截断
    至于truncate(n), 如若给出了n. 则从最早起头进⾏截断, 倘诺不给n, 则从前段时间岗位截断. 后⾯
    的剧情将会被去除

      1.seek()

     九. 修正⽂件以至另⼀种张开⽂件的⽅式
    ⽂件改进: 只可以将⽂件中的内容读取到内部存款和储蓄器中, 将音讯纠正完成, 然后将源⽂件删除, 将新
    ⽂件的名字改成老⽂件的名字

        seek(n) 光标移动到n地点,注意,移动的单位是byte.所以假如是UTF-8的华语部分若是3的倍数.

    新葡亰496net 10

        常常大家使⽤seek都是活动到起来恐怕结尾.

     

        移动到起来: seek(0)

         移动到终极: seek(0,2) seek的第⼆个参数表示的是从哪个岗位张开偏移, 暗中认可是0, 表示开始, 1表示近些日子职责, 2表示最终

     

    f = open("小娃娃",mode="r ",encoding="utf-8")
    f.seek(0)   #光标移动到开头
    content = f.read()   #读取内容,此时光标移动到结尾
    print(content)
    f.seek(0)       #再次将光标移动到开头
    f.seek(0,2)     #将光标移动到结尾
    content2 = f.read()     #读取内容,什么都没有
    print(content2)
    
    f.seek(0)       #移动到开头
    f.write("张国荣")  #写入信息,此时光标在9  中文3*3个 = 9
    
    f.flush()
    f.close()
    

     

     

       2.tell()使用tell()能够帮大家取获得当前光标在怎么着地点

    f = open("小娃娃",mode="r ",encoding="utf-8")
    f.seek(0)   #光标移动到开头
    content = f.read()   #读取内容,此时光标移动到结尾
    print(content)
    f.seek(0)       #再次将光标移动到开头
    f.seek(0,2)     #将光标移动到结尾
    content2 = f.read()     #读取内容,什么都没有
    print(content2)
    
    f.seek(0)       #移动到开头
    f.write("张国荣")  #写入信息,此时光标在9  中文3*3个 = 9
    
    f.flush()
    f.close()
    
    f = open("小娃娃",mode="r ",encoding="utf-8")
    f.seek(0)      #光标移动到开头
    content = f.read()  #读取内容,此时光标移动到结尾
    print(content)
    
    f.seek(0)       #再次将光标移动到开头
    f.seek(0,2)     #将光标移动到结尾
    content2 = f.read()     #读取内容,什么都没有
    print(content2)
    
    f.seek(0)   #移动到开头
    f.write("张国荣")      #写入信息,此时光标在9   中文3*3=9
    
    print(f.tell())     #光标位置9
    
    f.flush()
    f.close()
    

     

       3.截断文件truncate()

    f = open("小娃娃",mode="w",encoding="utf-8")
    f.write("哈哈")       #写入两个字符
    f.seek(3)
    f.truncate()    #删除光标后面的所有内容
    f.close()
    
    f = open("小娃娃",mode="r ",encoding="utf-8")
    content = f.read(3)     #读取12个字符
    f.seek(4)
    print(f.tell())
    f.truncate()        #后面的所有内容全部都删掉
    f.flush()
    f.close()
    

     

     

     深坑请小心:在r 形式下,如果读取了内容,无论读取内容有一点点,光标展现的是有些,再写入恐怕操作文件的时候都以在结尾进行的操作

    之所以如若想做截断操作,记住了,要先挪动光标,挪动到您想要截断的职分,然后再拓宽截断关于truncate(n),若是给出了n,则从先导举办截断,假使不给n,则从日前岗位截断,前面包车型地铁原委将会被去除

         4.改换文件以致另黄金年代种张开文件的章程

          文件更正:只可以将文件中的内容读取到内部存款和储蓄器中,将信息修正完结,然后将源文件删除,将新文件的名字改成老文件的名字

    import os
    with open("小娃娃",mode="r",encoding="utf-8") as f1,
        open("小娃娃_new",mode="w",encoding="utf-8") as f2:
        content = f1.read()
        new_content = content.replace("冰糖葫芦","大白梨")
        f2.write(new_content)
    os.remove("小娃娃")
    os.rename("小娃娃_new","小娃娃")
    

        破绽:二遍将有所内容实行读取,内部存款和储蓄器溢出,建设方案:生龙活虎行后生可畏行的读取和操作

    import os
    with open("小娃娃",mode="r",encoding="utf-8") as f1 ,
        open("小娃娃_new",mode="w",encoding="utf-8") as f2:
        for line in f1:
            new_line = line.replace("大白梨","冰糖葫芦")
            f2.write(new_line)
    os.remove("小娃娃")
    os.rename("小娃娃_new","小娃娃")
    

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    ---苏醒内容结束---

    本文由新葡亰496net发布于奥门新萄京娱乐场,转载请注明出处:新葡亰496net:文本操作,python全栈开荒

    关键词: