您的位置:新葡亰496net > 奥门新萄京娱乐场 > 新葡亰496net:文件操作,文件操作总结

新葡亰496net:文件操作,文件操作总结

发布时间:2019-07-21 05:09编辑:奥门新萄京娱乐场浏览(187)

      文件操作对于编程语言的重要性不言而喻,如果数据不能持久保存,信息技术也就失去了意义。

    python 文件操作总结,python文件操作总结

      文件操作对于编程语言的重要性不言而喻,如果数据不能持久保存,信息技术也就失去了意义。

      文件操作的内容包括打开文件,操作文件,关闭文件

    一、文件操作步骤

    1. 打开文件,得到文件句柄并赋值给一个变量
    2. 通过句柄对文件进行操作
    3. 关闭文件

    新葡亰496net 1新葡亰496net 2

    歌名:《大火》
    演唱:李佳薇
    作词:姚若龙
    作曲:马奕强
    歌词:
    有座巨大的停了的时钟
    倾倒在赶路的途中 挡我 向前走
    有只黑色的老鹰在俯冲
    叼走了你送的承诺 回头 冷冷看我
    有阵将眼泪扫落的狂风
    掀起了隐藏的疼痛 把我 变赤裸
    我为蔓延的回忆除草了
    心中却长出盛开的 寂寞 原来是梦
    有些伤痕像场大火 把心烧焦难以复活
    不碰了好像忘了 恐惧却在脑海住着
    重复卡在一个 重要的时刻 不自觉就会退缩
    连幸福也克制着 觉得什麽都会变的
    防备着平静到最後 连爱也透着冷漠
    有人说我的微笑是暖的
    心里却很难被感动 狠狠 解剖我
    从不是有意想害谁难过
    甚至会沮丧一直没突破 沉重的壳
    有些伤痕像场大火 把心烧焦难以复活
    不碰了好像忘了 恐惧却在脑海住着
    重复卡在一个 重要的时刻 不自觉就会退缩
    连幸福也克制着 觉得什麽都会变的
    防备着平静到最後 独自寂寞
    有些伤痕像场大火 把心烧焦难以复活
    可是我 想要忘了 恐惧如何把我上锁
    期待阳光炽热 爱来的时刻 能用力去拥抱着
    多幸福就多快乐 不让未知成为负荷
    投入的留下了每一刻 不怕的人 最富有
    人太脆弱 会不停错过
    太多宝贵的 都需要跋涉 才可以获得
    太多璀璨的 越隔着夜色 越光芒四射
    

    示范文件内容

    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的作⽤:

    在读取非⽂本⽂件的时候. 比如读取MP3. 图像. 视频等信息的时候就需要⽤到 rb. 因为这种数据是没

    办法直接显⽰出来的. 在后⾯我们⽂件上传下载的时候还会⽤到. 还有. 我们看的直播. 实际上都是这

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

    夹下的⽂件. 相对于当前这个程序所在的⽂件夹⽽⾔. 如果在同 ⼀个⽂件夹中. 则相对路径就是这个⽂

    件名. 如果在上⼀层⽂件夹. 则要../

    新葡亰496net 3

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

    python基础-文件操作,

    一、文件操作

          打开文件时,需要指定文件路径和以何等方式打开文件,打开后,即可获取该文件句柄,日后通过此文件句柄对该文件操作。

    打开文件的模式有:

    • r ,只读模式【默认模式,文件必须存在,不存在则抛出异常】
    • w,只写模式【不可读;不存在则创建;存在则清空内容】
    • x, 只写模式【不可读;不存在则创建,存在则报错】
    • a, 追加模式【可读;   不存在则创建;存在则只追加内容】

    " " 表示可以同时读写某个文件

    • r , 读写【可读,可写】
    • w ,写读【可读,可写】
    • x ,写读【可读,可写】
    • a , 写读【可读,可写】

     "b"表示以字节的方式操作

    • rb  或 r b
    • wb 或 w b
    • xb 或 w b
    • ab 或 a b

     注:以b方式打开时,读取到的内容是字节类型,写入时也需要提供字节类型,不能指定编码

     

    Table 文件对象方法

    方法 描述
    f.close() 关闭文件,记住用open()打开文件后一定要记得关闭它,否则会占用系统的可打开文件句柄数。
    f.fileno() 获得文件描述符,是一个数字
    f.flush() 刷新输出缓存
    f.isatty() 如果文件是一个交互终端,则返回True,否则返回False。
    f.read([count]) 读出文件,如果有count,则读出count个字节。
    f.readline() 读出一行信息。
    f.readlines() 读出所有行,也就是读出整个文件的信息。
    f.seek(offset[,where]) 把文件指针移动到相对于where的offset位置。where为0表示文件开始处,这是默认值 ;1表示当前位置;2表示文件结尾。
    f.tell() 获得文件指针位置。
    f.truncate([size]) 截取文件,使文件的大小为size。
    f.write(string) 把string字符串写入文件。
    f.writelines(list) 把list中的字符串一行一行地写入文件,是连续写入文件,没有换行。

     


     read(3)代表读取3个字符,其余的文件内光标移动是以字节为单位,如:seek,tell,read,truncate

    f.flush()      #讲文件内容从内存刷到硬盘(python3.x)

    f.closed       #文件如果关闭则返回True

    f.encoding   #查看使用open打开文件的编码

    f.tell()         #查看文件处理当前的光标位置

    f.seek(3)     #从开头开始算,将光标移动到第三个字节

    f.truncate(10) #从开头开始算,将文件只保留从0-10个字节的内容,文件必须以写方式打开,但是w和w 除外。

     


     

    对文件操作的流程

    示例

     1 Somehow, it seems the love I knew was always the most destructive kind
     2 不知为何,我经历的爱情总是最具毁灭性的的那种
     3 Yesterday when I was young
     4 昨日当我年少轻狂
     5 The taste of life was sweet
     6 生命的滋味是甜的
     7 As rain upon my tongue
     8 就如舌尖上的雨露
     9 I teased at life as if it were a foolish game
    10 我戏弄生命 视其为愚蠢的游戏
    11 The way the evening breeze
    12 就如夜晚的微风
    13 May tease the candle flame
    14 逗弄蜡烛的火苗
    15 The thousand dreams I dreamed
    16 我曾千万次梦见
    17 The splendid things I planned
    18 那些我计划的绚丽蓝图
    19 I always built to last on weak and shifting sand
    20 但我总是将之建筑在易逝的流沙上
    21 I lived by night and shunned the naked light of day
    22 我夜夜笙歌 逃避白昼赤裸的阳光
    23 And only now I see how the time ran away
    24 事到如今我才看清岁月是如何匆匆流逝
    25 Yesterday when I was young
    26 昨日当我年少轻狂
    27 So many lovely songs were waiting to be sung
    28 有那么多甜美的曲儿等我歌唱
    29 So many wild pleasures lay in store for me
    30 有那么多肆意的快乐等我享受
    31 And so much pain my eyes refused to see
    32 还有那么多痛苦 我的双眼却视而不见
    33 I ran so fast that time and youth at last ran out
    34 我飞快地奔走 最终时光与青春消逝殆尽
    35 I never stopped to think what life was all about
    36 我从未停下脚步去思考生命的意义
    37 And every conversation that I can now recall
    38 如今回想起的所有对话
    39 Concerned itself with me and nothing else at all
    40 除了和我相关的 什么都记不得了
    41 The game of love I played with arrogance and pride
    42 我用自负和傲慢玩着爱情的游戏
    43 And every flame I lit too quickly, quickly died
    44 所有我点燃的火焰都熄灭得太快
    45 The friends I made all somehow seemed to slip away
    46 所有我交的朋友似乎都不知不觉地离开了
    47 And only now I'm left alone to end the play, yeah
    48 只剩我一个人在台上来结束这场闹剧
    49 Oh, yesterday when I was young
    50 噢 昨日当我年少轻狂
    51 So many, many songs were waiting to be sung
    52 有那么那么多甜美的曲儿等我歌唱
    53 So many wild pleasures lay in store for me
    54 有那么多肆意的快乐等我享受
    55 And so much pain my eyes refused to see
    56 还有那么多痛苦 我的双眼却视而不见
    57 There are so many songs in me that won't be sung
    58 我有太多歌曲永远不会被唱起
    59 I feel the bitter taste of tears upon my tongue
    60 我尝到了舌尖泪水的苦涩滋味
    61 The time has come for me to pay for yesterday
    62 终于到了付出代价的时间 为了昨日
    63 When I was young
    64 当我年少轻狂
    

    基本操作 

    1 f = open('lyrics') #打开文件
    2 first_line = f.readline()
    3 print('first line:',first_line) #读一行
    4 print('我是分隔线'.center(50,'-'))
    5 data = f.read()# 读取剩下的所有内容,文件大时不要用
    6 print(data) #打印文件
    7  
    8 f.close() #关闭文件
    

     

    打开文件的模式有:

    • r,只读模式(默认)。
    • w,只写模式。【不可读;不存在则创建;存在则删除内容;】
    • a,追加模式。【可读;   不存在则创建;存在则只追加内容;】

     

      文件操作的内容包括打开文件,操作文件,关闭文件

    一,打开文件

      python中打开文件的函数为open('filename',mode='r',encode='None'),open函数默认返回文件的句柄,我们可以根据句柄来对文件进行增,删,改,查的操作。将句柄赋给我们定义的变量,假设我们定义变量为f,则f=open('filename',mode='r',encode='utf-8') 或者with open('filename') as f。

    注意点:

      1.python解释器打开文件时,是对硬盘进行操作,需要内核态才可以操作硬盘,故此时python解释器是调用操作系统的文件读取接口。windows中文版本默认使用GBK编码表,linux默认使用utf-8,所有如果操作的文件在windows下,非GBK编码的,需要在open函数中声明编码类型,使操作系统运用相应的编码规则进行解码读取,防止串码,乱码现象。

      2.open主要有三种模式,读(r),写(w),追加(a),其中,默认为读模式。各个模式的详解,见下文。

    二、文件操作详解

    操作文件时,一般需要经历如下步骤:

    • 打开文件
    • 操作文件
    • 关闭文件

    读取⽂件的⽅法: 1. read() 将⽂件中的内容全部读取出来. 弊端: 占内存. 如果⽂件过⼤.容易导致内存崩溃

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

    读文件示例

    法1:

    1、先创建一个文件名称为:yesterday文本文件,内容如下:

     1 Somehow, it seems the love I knew was always the most destructive kind
     2 不知为何,我经历的爱情总是最具毁灭性的的那种
     3 Yesterday when I was young
     4 昨日当我年少轻狂
     5 The taste of life was sweet
     6 生命的滋味是甜的
     7 As rain upon my tongue
     8 就如舌尖上的雨露
     9 I teased at life as if it were a foolish game
    10 我戏弄生命 视其为愚蠢的游戏
    11 The way the evening breeze
    12 就如夜晚的微风
    13 May tease the candle flame
    14 逗弄蜡烛的火苗
    15 The thousand dreams I dreamed
    16 我曾千万次梦见
    17 The splendid things I planned
    18 那些我计划的绚丽蓝图
    19 I always built to last on weak and shifting sand
    20 但我总是将之建筑在易逝的流沙上
    21 I lived by night and shunned the naked light of day
    22 我夜夜笙歌 逃避白昼赤裸的阳光
    23 And only now I see how the time ran away
    24 事到如今我才看清岁月是如何匆匆流逝
    25 Yesterday when I was young
    26 昨日当我年少轻狂
    27 So many lovely songs were waiting to be sung
    28 有那么多甜美的曲儿等我歌唱
    29 So many wild pleasures lay in store for me
    30 有那么多肆意的快乐等我享受
    31 And so much pain my eyes refused to see
    32 还有那么多痛苦 我的双眼却视而不见
    33 I ran so fast that time and youth at last ran out
    34 我飞快地奔走 最终时光与青春消逝殆尽
    35 I never stopped to think what life was all about
    36 我从未停下脚步去思考生命的意义
    37 And every conversation that I can now recall
    38 如今回想起的所有对话
    39 Concerned itself with me and nothing else at all
    40 除了和我相关的 什么都记不得了
    41 The game of love I played with arrogance and pride
    42 我用自负和傲慢玩着爱情的游戏
    43 And every flame I lit too quickly, quickly died
    44 所有我点燃的火焰都熄灭得太快
    45 The friends I made all somehow seemed to slip away
    46 所有我交的朋友似乎都不知不觉地离开了
    47 And only now I'm left alone to end the play, yeah
    48 只剩我一个人在台上来结束这场闹剧
    49 Oh, yesterday when I was young
    50 噢 昨日当我年少轻狂
    51 So many, many songs were waiting to be sung
    52 有那么那么多甜美的曲儿等我歌唱
    53 So many wild pleasures lay in store for me
    54 有那么多肆意的快乐等我享受
    55 And so much pain my eyes refused to see
    56 还有那么多痛苦 我的双眼却视而不见
    57 There are so many songs in me that won't be sung
    58 我有太多歌曲永远不会被唱起
    59 I feel the bitter taste of tears upon my tongue
    60 我尝到了舌尖泪水的苦涩滋味
    61 The time has come for me to pay for yesterday
    62 终于到了付出代价的时间 为了昨日
    63 When I was young
    64 当我年少轻狂
    

    读取文件

    1 #!/usr/bin/env python
    2 # -*- coding:utf-8 -*-
    3 #Author: nulige
    4 #读取文件内容,并打印出来
    5 data = open("yesterday",encoding="utf-8").read()
    6 print(data)
    

     

    读出上面那个文件里的内容

    执行结果:

     1 Somehow, it seems the love I knew was always the most destructive kind
     2 不知为何,我经历的爱情总是最具毁灭性的的那种
     3 Yesterday when I was young
     4 昨日当我年少轻狂
     5 The taste of life was sweet
     6 生命的滋味是甜的
     7 As rain upon my tongue
     8 就如舌尖上的雨露
     9 I teased at life as if it were a foolish game
    10 我戏弄生命 视其为愚蠢的游戏
    11 The way the evening breeze
    12 就如夜晚的微风
    13 May tease the candle flame
    14 逗弄蜡烛的火苗
    15 The thousand dreams I dreamed
    16 我曾千万次梦见
    17 The splendid things I planned
    18 那些我计划的绚丽蓝图
    19 I always built to last on weak and shifting sand
    20 但我总是将之建筑在易逝的流沙上
    21 I lived by night and shunned the naked light of day
    22 我夜夜笙歌 逃避白昼赤裸的阳光
    23 And only now I see how the time ran away
    24 事到如今我才看清岁月是如何匆匆流逝
    25 Yesterday when I was young
    26 昨日当我年少轻狂
    27 So many lovely songs were waiting to be sung
    28 有那么多甜美的曲儿等我歌唱
    29 So many wild pleasures lay in store for me
    30 有那么多肆意的快乐等我享受
    31 And so much pain my eyes refused to see
    32 还有那么多痛苦 我的双眼却视而不见
    33 I ran so fast that time and youth at last ran out
    34 我飞快地奔走 最终时光与青春消逝殆尽
    35 I never stopped to think what life was all about
    36 我从未停下脚步去思考生命的意义
    37 And every conversation that I can now recall
    38 如今回想起的所有对话
    39 Concerned itself with me and nothing else at all
    40 除了和我相关的 什么都记不得了
    41 The game of love I played with arrogance and pride
    42 我用自负和傲慢玩着爱情的游戏
    43 And every flame I lit too quickly, quickly died
    44 所有我点燃的火焰都熄灭得太快
    45 The friends I made all somehow seemed to slip away
    46 所有我交的朋友似乎都不知不觉地离开了
    47 And only now I'm left alone to end the play, yeah
    48 只剩我一个人在台上来结束这场闹剧
    49 Oh, yesterday when I was young
    50 噢 昨日当我年少轻狂
    51 So many, many songs were waiting to be sung
    52 有那么那么多甜美的曲儿等我歌唱
    53 So many wild pleasures lay in store for me
    54 有那么多肆意的快乐等我享受
    55 And so much pain my eyes refused to see
    56 还有那么多痛苦 我的双眼却视而不见
    57 There are so many songs in me that won't be sung
    58 我有太多歌曲永远不会被唱起
    59 I feel the bitter taste of tears upon my tongue
    60 我尝到了舌尖泪水的苦涩滋味
    61 The time has come for me to pay for yesterday
    62 终于到了付出代价的时间 为了昨日
    63 When I was young
    64 当我年少轻狂
    

     

     法2:

    实验没有做成功。没有输出data2的结果

     1 #!/usr/bin/env python
     2 # -*- coding:utf-8 -*-
     3 #Author: nulige
     4 
     5 #data = open("yesterday",encoding="utf-8").read()
     6 #打开的文件内存对像,给他赋一个变量,再去读取这个变量,找到这个值
     7 f = open("yesterday",encoding="utf-8")  #文件句柄(文件内存对像。包含 (文件名,字符集,大小,硬盘的起启位置))
     8 data = f.read()
     9 data2 = f.read()
    10 print(data)
    11 print('--------------data2---------------',data2)
    

    结果:

    只输出data1的结果

    实验没有做成功。没有输出data2的结果。

     


     读取和写入内容示例(错误的操作方法)

    这种方法有个特性:要么只读,要么只写。不能同时读又写.同时会清空文件中的内容。特别危险。(从删除库到跑路示例 !)

    r   :读

    w  :写

     1 # -*- coding:utf-8 -*-
     2 #Author: nulige
     3 
     4 #这种方法有个特性:要么只读,要么只写。不能同时读又写.同时会清空文件中的内容。特别危险。
     5 #data = open("yesterday",encoding="utf-8").read()
     6 #打开的文件内存对像,给他赋一个变量,再去读取这个变量,找到这个值
     7 #f = open("yesterday","r",encoding="utf-8")  #文件句柄(文件内存对像。包含 (文件名,字符集,大小,硬盘的起启位置))
     8 f = open("yesterday","w",encoding="utf-8")
     9 data = f.read()
    10 print(data)
    11 f.write("我爱北京天安门")
    

    执行结果:

    会报错的,不能同时又读又写

    1 Traceback (most recent call last):
    2   File "D:/python/day3/file_open.py", line 10, in <module>
    3     data = f.read()
    4 io.UnsupportedOperation: not readable
    

     

    查看yesterday文本文件中的内容发现,内容全被清空啦。

    (文件内没有内容)

     


     往文件中写入内容

    1、先创建一个文件名称为:yesterday文本文件,内容为上面那首歌。

     

    2、再创建一个file_open.py的文件

    内容如下:

    1 #!/usr/bin/env python
    2 # -*- coding:utf-8 -*-
    3 #Author: nulige
    4 
    5 #读文件或打开文件
    6 #data = open("yesterday",encoding="utf-8").read()
    7 f = open("yesterday",encoding="utf-8")   #文件句柄
    8 data = f.read()
    9 print(data)
    

    执行结果:

    新葡亰496net 4

     1 Somehow, it seems the love I knew was always the most destructive kind
     2 不知为何,我经历的爱情总是最具毁灭性的的那种
     3 Yesterday when I was young
     4 昨日当我年少轻狂
     5 The taste of life was sweet
     6 生命的滋味是甜的
     7 As rain upon my tongue
     8 就如舌尖上的雨露
     9 I teased at life as if it were a foolish game
    10 我戏弄生命 视其为愚蠢的游戏
    11 The way the evening breeze
    12 就如夜晚的微风
    13 May tease the candle flame
    14 逗弄蜡烛的火苗
    15 The thousand dreams I dreamed
    16 我曾千万次梦见
    17 The splendid things I planned
    18 那些我计划的绚丽蓝图
    19 I always built to last on weak and shifting sand
    20 但我总是将之建筑在易逝的流沙上
    21 I lived by night and shunned the naked light of day
    22 我夜夜笙歌 逃避白昼赤裸的阳光
    23 And only now I see how the time ran away
    24 事到如今我才看清岁月是如何匆匆流逝
    25 Yesterday when I was young
    26 昨日当我年少轻狂
    27 So many lovely songs were waiting to be sung
    28 有那么多甜美的曲儿等我歌唱
    29 So many wild pleasures lay in store for me
    30 有那么多肆意的快乐等我享受
    31 And so much pain my eyes refused to see
    32 还有那么多痛苦 我的双眼却视而不见
    33 I ran so fast that time and youth at last ran out
    34 我飞快地奔走 最终时光与青春消逝殆尽
    35 I never stopped to think what life was all about
    36 我从未停下脚步去思考生命的意义
    37 And every conversation that I can now recall
    38 如今回想起的所有对话
    39 Concerned itself with me and nothing else at all
    40 除了和我相关的 什么都记不得了
    41 The game of love I played with arrogance and pride
    42 我用自负和傲慢玩着爱情的游戏
    43 And every flame I lit too quickly, quickly died
    44 所有我点燃的火焰都熄灭得太快
    45 The friends I made all somehow seemed to slip away
    46 所有我交的朋友似乎都不知不觉地离开了
    47 And only now I'm left alone to end the play, yeah
    48 只剩我一个人在台上来结束这场闹剧
    49 Oh, yesterday when I was young
    50 噢 昨日当我年少轻狂
    51 So many, many songs were waiting to be sung
    52 有那么那么多甜美的曲儿等我歌唱
    53 So many wild pleasures lay in store for me
    54 有那么多肆意的快乐等我享受
    55 And so much pain my eyes refused to see
    56 还有那么多痛苦 我的双眼却视而不见
    57 There are so many songs in me that won't be sung
    58 我有太多歌曲永远不会被唱起
    59 I feel the bitter taste of tears upon my tongue
    60 我尝到了舌尖泪水的苦涩滋味
    61 The time has come for me to pay for yesterday
    62 终于到了付出代价的时间 为了昨日
    63 When I was young
    64 当我年少轻狂
    

    View Code

    write创建一个文件名为:yesterday2的新文件,并可以写入内容
    
    1 #!/usr/bin/env python
    2 # -*- coding:utf-8 -*-
    3 #Author: nulige
    4 
    5 f = open("yesterday2",'w',encoding="utf-8")   #文件句柄
    6 f.write("我爱北京天安门,n")    # write创建一个新文件,并可以写入内容
    7 f.write("天安门前太阳升")
    

    执行结果:

    yesterday2.txt

    1 我爱北京天安门,
    2 天安门前太阳升
    

     

    一,打开文件

      python中打开文件的函数为open('filename',mode='r',encode='None'),open函数默认返回文件的句柄,我们可以根据句柄来对文件进行增,删,改,查的操作。将句柄赋给我们定义的变量,假设我们定义变量为f,则f=open('filename',mode='r',encode='utf-8') 或者with open('filename') as f。

    注意点:

      1.python解释器打开文件时,是对硬盘进行操作,需要内核态才可以操作硬盘,故此时python解释器是调用操作系统的文件读取接口。windows中文版本默认使用GBK编码表,linux默认使用utf-8,所有如果操作的文件在windows下,非GBK编码的,需要在open函数中声明编码类型,使操作系统运用相应的编码规则进行解码读取,防止串码,乱码现象。

      2.open主要有三种模式,读(r),写(w),追加(a),其中,默认为读模式。各个模式的详解,见下文。

    二,关闭文件

    关闭文件有两组方式:

      1.使用f.close()  ,f为open返回的句柄赋值的变量名。

       2.程序结束后,自动关闭。第一个方法容易造成文件写操作时,数据的丢失。原因是写数据时,数据会先保存在内存中,文件关闭时才会写入硬盘,此时如果文件未关闭,软件因为异常崩溃,导致内存中的数据丢失,且未写入硬盘中。作为第一种关闭方法的优化,是使用:with open('filename') as f 。with会创建一个程序块,将文件操作置于with程序块下,这样with控制块结束,文件也会自动关闭。

    语法如下:

    with open('f1.txt') as f1 , open('f2.txt') as f2:
        ......
    

      

    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)
    #结果:
    友谊地
    久天⻓
    

    追加文件示例

    方法1:

    1、先创建一个名称为:yesterday2空文件

    2、再创建一个file_open.py的文件

     1 #!/usr/bin/env python
     2 # -*- coding:utf-8 -*-
     3 #Author: nulige
     4 
     5 #这种方法有个特性:要么只读,要么只写。不能同时读又写.同时会清空文件中的内容。特别危险。
     6 #data = open("yesterday",encoding="utf-8").read()
     7 #打开的文件内存对像,给他赋一个变量,再去读取这个变量,找到这个值
     8 #f = open("yesterday","r",encoding="utf-8")  #文件句柄(文件内存对像。包含 (文件名,字符集,大小,硬盘的起启位置))
     9 f = open("yesterday2","w",encoding="utf-8")
    10 
    11 f.write("我爱北京天安门,")
    12 f.write("天安门上太阳升")
    

    执行结果:

    yesterday2 会在左边写入一个文件,然后双击那个文件,创建一个名称这yesterday2的文本文件。

    并会往里面写入内容:

    1 我爱北京天安门,天安门上太阳升
    

     

    方法二:

    1、先创建一个名称为:yesterday2空文件

    2、再创建一个file_open.py的文件

    内容如下:

    1 #!/usr/bin/env python
    2 # -*- coding:utf-8 -*-
    3 #Author: nulige
    4 
    5 f = open("yesterday2",'a',encoding="utf-8")   #文件句柄
    6 #a = append 追加
    7 f.write("我爱北京天安门.....n")
    8 f.write("天安门上太阳升....")
    9 f.close()
    

    执行结果:

    会往里面追加内容并换行。换行符用n 表示

    1 我爱北京天安门
    2 天安门上太阳升
    3 我爱北京天安门.....
    4 天安门上太阳升....
    

     

    二,关闭文件

    关闭文件有两组方式:

      1.使用f.close()  ,f为open返回的句柄赋值的变量名。

       2.程序结束后,自动关闭。第一个方法容易造成文件写操作时,数据的丢失。原因是写数据时,数据会先保存在内存中,文件关闭时才会写入硬盘,此时如果文件未关闭,软件因为异常崩溃,导致内存中的数据丢失,且未写入硬盘中。作为第一种关闭方法的优化,是使用:with open('filename') as f 。with会创建一个程序块,将文件操作置于with程序块下,这样with控制块结束,文件也会自动关闭。

    语法如下:

    with open('f1.txt') as f1 , open('f2.txt') as f2:
        ......
    

      

    三,操作文件

    open 函数

    你必须先用Python内置的open()函数打开一个文件,创建一个file对象,相关的方法才可以调用它进行读写。

    语法:

    file object = open(file_name [, access_mode][, buffering])
    

      各个参数的细节如下:

    • file_name:file_name变量是一个包含了你要访问的文件名称的字符串值。
    • access_mode:access_mode决定了打开文件的模式:只读,写入,追加等。所有可取值见如下的完全列表。这个参数是非强制的,默认文件访问模式为只读(r)。
    • buffering:如果buffering的值被设为0,就不会有寄存。如果buffering的值取1,访问文件时会寄存行。如果将buffering的值设为大于1的整数,表明了这就是的寄存区的缓冲大小。如果取负值,寄存区的缓冲大小则为系统默认。

    注: python中打开文件有两种方式,即:open(...) 和  file(...) ,本质上前者在内部会调用后者来进行文件操作,推荐使用 open

    打开文件时,需要指定文件路径和以何等方式打开文件,打开后,即可获取该文件句柄,日后通过此文件句柄对该文件操作。

    打开文件的模式有:

    • r ,只读模式【默认模式,文件必须存在,不存在则抛出异常】
    • w,只写模式【不可读;不存在则创建;存在则清空内容】
    • x, 只写模式【不可读;不存在则创建,存在则报错】
    • a, 追加模式【可读;   不存在则创建;存在则只追加内容】

    " " 表示可以同时读写某个文件

    • r , 读写【可读,可写】
    • w ,写读【可读,可写】
    • x ,写读【可读,可写】
    • a , 写读【可读,可写】

    "U"表示在读取时,可以将 r n rn自动转换成 n (与 r 或 r 模式同使用)

    • rU
    • r U

     "b"表示以字节的方式操作

    • rb  或 r b
    • wb 或 w b
    • xb 或 w b
    • ab 或 a b

     注:以b方式打开时,读取到的内容是字节类型,写入时也需要提供字节类型,不能指定编码。

    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)
    #结果:
    友谊地久天⻓,
    爱⼀点,
    可惜我是⽔瓶座
    ⼀⽣中最爱
    

    用了a 追加方法,再去读取文件会报错 (只能追加,不能再去读取)

     1 #!/usr/bin/env python
     2 # -*- coding:utf-8 -*-
     3 #Author: nulige
     4 
     5 #用了a 追加方法,再去读取文件会报错  (只能追加,不能再去读取)
     6 f = open("yesterday2",'a',encoding="utf-8")   #文件句柄
     7 #a = append 追加
     8 
     9 f.write("nwhen i was young i listen to the radion")
    10 data = f.read()
    11 print(' read',data)
    

    执行结果:

    1 Traceback (most recent call last):
    2   File "D:/python/day3/file_open.py", line 10, in <module>
    3     data = f.read()
    4 io.UnsupportedOperation: not readable
    

     


     读取文件前5行示例

    1、选创建一个文本文件,取名为yesterday2。

    内容为:

    新葡亰496net 5

     1 Somehow, it seems the love I knew was always the most destructive kind
     2 不知为何,我经历的爱情总是最具毁灭性的的那种
     3 Yesterday when I was young
     4 昨日当我年少轻狂
     5 The taste of life was sweet
     6 生命的滋味是甜的
     7 As rain upon my tongue
     8 就如舌尖上的雨露
     9 I teased at life as if it were a foolish game
    10 我戏弄生命 视其为愚蠢的游戏
    11 The way the evening breeze
    12 就如夜晚的微风
    13 May tease the candle flame
    14 逗弄蜡烛的火苗
    15 The thousand dreams I dreamed
    16 我曾千万次梦见
    17 The splendid things I planned
    18 那些我计划的绚丽蓝图
    19 I always built to last on weak and shifting sand
    20 但我总是将之建筑在易逝的流沙上
    21 I lived by night and shunned the naked light of day
    22 我夜夜笙歌 逃避白昼赤裸的阳光
    23 And only now I see how the time ran away
    24 事到如今我才看清岁月是如何匆匆流逝
    25 Yesterday when I was young
    26 昨日当我年少轻狂
    27 So many lovely songs were waiting to be sung
    28 有那么多甜美的曲儿等我歌唱
    29 So many wild pleasures lay in store for me
    30 有那么多肆意的快乐等我享受
    31 And so much pain my eyes refused to see
    32 还有那么多痛苦 我的双眼却视而不见
    33 I ran so fast that time and youth at last ran out
    34 我飞快地奔走 最终时光与青春消逝殆尽
    35 I never stopped to think what life was all about
    36 我从未停下脚步去思考生命的意义
    37 And every conversation that I can now recall
    38 如今回想起的所有对话
    39 Concerned itself with me and nothing else at all
    40 除了和我相关的 什么都记不得了
    41 The game of love I played with arrogance and pride
    42 我用自负和傲慢玩着爱情的游戏
    43 And every flame I lit too quickly, quickly died
    44 所有我点燃的火焰都熄灭得太快
    45 The friends I made all somehow seemed to slip away
    46 所有我交的朋友似乎都不知不觉地离开了
    47 And only now I'm left alone to end the play, yeah
    48 只剩我一个人在台上来结束这场闹剧
    49 Oh, yesterday when I was young
    50 噢 昨日当我年少轻狂
    51 So many, many songs were waiting to be sung
    52 有那么那么多甜美的曲儿等我歌唱
    53 So many wild pleasures lay in store for me
    54 有那么多肆意的快乐等我享受
    55 And so much pain my eyes refused to see
    56 还有那么多痛苦 我的双眼却视而不见
    57 There are so many songs in me that won't be sung
    58 我有太多歌曲永远不会被唱起
    59 I feel the bitter taste of tears upon my tongue
    60 我尝到了舌尖泪水的苦涩滋味
    61 The time has come for me to pay for yesterday
    62 终于到了付出代价的时间 为了昨日
    63 When I was young
    64 当我年少轻狂
    

    View Code

    2、实现读取文件前五行

    法1:

     1 #!/usr/bin/env python
     2 # -*- coding:utf-8 -*-
     3 #Author: nulige
     4 
     5 #读取前5行
     6 print(f.readline())      #读取一行,搞五次,就是读取五行,这个方法好笨哦!!!
     7 print(f.readline())
     8 print(f.readline())
     9 print(f.readline())
    10 print(f.readline())
    

    法2:

    1 #!/usr/bin/env python
    2 # -*- coding:utf-8 -*-
    3 #Author: nulige
    4 
    5 #用循环的方法,循环五次
    6 f = open("yesterday2",'r',encoding="utf-8")
    7 for i in range(5):
    8     print(f.readline())
    

    执行结果:

    1 Somehow, it seems the love I knew was always the most destructive kind
    2 
    3 不知为何,我经历的爱情总是最具毁灭性的的那种
    4 
    5 Yesterday when I was young
    6 
    7 昨日当我年少轻狂
    8 
    9 The taste of life was sweet
    

     打印出文件所有内容

    1 #!/usr/bin/env python
    2 # -*- coding:utf-8 -*-
    3 #Author: nulige
    4 
    5 f = open("yesterday2",'r',encoding="utf-8")
    6 
    7 for line in f.readlines():
    8     print(line)
    

    执行结果:

    新葡亰496net 6

      1 不知为何,我经历的爱情总是最具毁灭性的的那种
      2 
      3 Yesterday when I was young
      4 
      5 昨日当我年少轻狂
      6 
      7 The taste of life was sweet
      8 
      9 生命的滋味是甜的
     10 
     11 As rain upon my tongue
     12 
     13 就如舌尖上的雨露
     14 
     15 I teased at life as if it were a foolish game
     16 
     17 我戏弄生命 视其为愚蠢的游戏
     18 
     19 The way the evening breeze
     20 
     21 就如夜晚的微风
     22 
     23 May tease the candle flame
     24 
     25 逗弄蜡烛的火苗
     26 
     27 The thousand dreams I dreamed
     28 
     29 我曾千万次梦见
     30 
     31 The splendid things I planned
     32 
     33 那些我计划的绚丽蓝图
     34 
     35 I always built to last on weak and shifting sand
     36 
     37 但我总是将之建筑在易逝的流沙上
     38 
     39 I lived by night and shunned the naked light of day
     40 
     41 我夜夜笙歌 逃避白昼赤裸的阳光
     42 
     43 And only now I see how the time ran away
     44 
     45 事到如今我才看清岁月是如何匆匆流逝
     46 
     47 Yesterday when I was young
     48 
     49 昨日当我年少轻狂
     50 
     51 So many lovely songs were waiting to be sung
     52 
     53 有那么多甜美的曲儿等我歌唱
     54 
     55 So many wild pleasures lay in store for me
     56 
     57 有那么多肆意的快乐等我享受
     58 
     59 And so much pain my eyes refused to see
     60 
     61 还有那么多痛苦 我的双眼却视而不见
     62 
     63 I ran so fast that time and youth at last ran out
     64 
     65 我飞快地奔走 最终时光与青春消逝殆尽
     66 
     67 I never stopped to think what life was all about
     68 
     69 我从未停下脚步去思考生命的意义
     70 
     71 And every conversation that I can now recall
     72 
     73 如今回想起的所有对话
     74 
     75 Concerned itself with me and nothing else at all
     76 
     77 除了和我相关的 什么都记不得了
     78 
     79 The game of love I played with arrogance and pride
     80 
     81 我用自负和傲慢玩着爱情的游戏
     82 
     83 And every flame I lit too quickly, quickly died
     84 
     85 所有我点燃的火焰都熄灭得太快
     86 
     87 The friends I made all somehow seemed to slip away
     88 
     89 所有我交的朋友似乎都不知不觉地离开了
     90 
     91 And only now I'm left alone to end the play, yeah
     92 
     93 只剩我一个人在台上来结束这场闹剧
     94 
     95 Oh, yesterday when I was young
     96 
     97 噢 昨日当我年少轻狂
     98 
     99 So many, many songs were waiting to be sung
    100 
    101 有那么那么多甜美的曲儿等我歌唱
    102 
    103 So many wild pleasures lay in store for me
    104 
    105 有那么多肆意的快乐等我享受
    106 
    107 And so much pain my eyes refused to see
    108 
    109 还有那么多痛苦 我的双眼却视而不见
    110 
    111 There are so many songs in me that won't be sung
    112 
    113 我有太多歌曲永远不会被唱起
    114 
    115 I feel the bitter taste of tears upon my tongue
    116 
    117 我尝到了舌尖泪水的苦涩滋味
    118 
    119 The time has come for me to pay for yesterday
    120 
    121 终于到了付出代价的时间 为了昨日
    122 
    123 When I was young
    124 
    125 当我年少轻狂
    

    View Code

     

    用strip()  去掉空格和换行,打印出所有内容

    1 #!/usr/bin/env python
    2 # -*- coding:utf-8 -*-
    3 #Author: nulige
    4 
    5 f = open("yesterday2",'r',encoding="utf-8")
    6 
    7 for line in f.readlines():
    8     print(line.strip())
    

    执行结果:

    新葡亰496net 7

     1 Somehow, it seems the love I knew was always the most destructive kind
     2 不知为何,我经历的爱情总是最具毁灭性的的那种
     3 Yesterday when I was young
     4 昨日当我年少轻狂
     5 The taste of life was sweet
     6 生命的滋味是甜的
     7 As rain upon my tongue
     8 就如舌尖上的雨露
     9 I teased at life as if it were a foolish game
    10 我戏弄生命 视其为愚蠢的游戏
    11 The way the evening breeze
    12 就如夜晚的微风
    13 May tease the candle flame
    14 逗弄蜡烛的火苗
    15 The thousand dreams I dreamed
    16 我曾千万次梦见
    17 The splendid things I planned
    18 那些我计划的绚丽蓝图
    19 I always built to last on weak and shifting sand
    20 但我总是将之建筑在易逝的流沙上
    21 I lived by night and shunned the naked light of day
    22 我夜夜笙歌 逃避白昼赤裸的阳光
    23 And only now I see how the time ran away
    24 事到如今我才看清岁月是如何匆匆流逝
    25 Yesterday when I was young
    26 昨日当我年少轻狂
    27 So many lovely songs were waiting to be sung
    28 有那么多甜美的曲儿等我歌唱
    29 So many wild pleasures lay in store for me
    30 有那么多肆意的快乐等我享受
    31 And so much pain my eyes refused to see
    32 还有那么多痛苦 我的双眼却视而不见
    33 I ran so fast that time and youth at last ran out
    34 我飞快地奔走 最终时光与青春消逝殆尽
    35 I never stopped to think what life was all about
    36 我从未停下脚步去思考生命的意义
    37 And every conversation that I can now recall
    38 如今回想起的所有对话
    39 Concerned itself with me and nothing else at all
    40 除了和我相关的 什么都记不得了
    41 The game of love I played with arrogance and pride
    42 我用自负和傲慢玩着爱情的游戏
    43 And every flame I lit too quickly, quickly died
    44 所有我点燃的火焰都熄灭得太快
    45 The friends I made all somehow seemed to slip away
    46 所有我交的朋友似乎都不知不觉地离开了
    47 And only now I'm left alone to end the play, yeah
    48 只剩我一个人在台上来结束这场闹剧
    49 Oh, yesterday when I was young
    50 噢 昨日当我年少轻狂
    51 So many, many songs were waiting to be sung
    52 有那么那么多甜美的曲儿等我歌唱
    53 So many wild pleasures lay in store for me
    54 有那么多肆意的快乐等我享受
    55 And so much pain my eyes refused to see
    56 还有那么多痛苦 我的双眼却视而不见
    57 There are so many songs in me that won't be sung
    58 我有太多歌曲永远不会被唱起
    59 I feel the bitter taste of tears upon my tongue
    60 我尝到了舌尖泪水的苦涩滋味
    61 The time has come for me to pay for yesterday
    62 终于到了付出代价的时间 为了昨日
    63 When I was young
    64 当我年少轻狂
    

    View Code

     

    三,操作文件

    3.1 file的基本方法

    方法

    功能

    F.read([size])  

    size为读取的长度,以byte为单位

    F.readline([size]) 

    如果定义了size,有可能返回的只是一行的一部分 

    F.readlines([size]) 

    把文件每一行作为一个list的一个成员,并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数,size是表示读取内容的总长,也就是说可能只读到文件的一部分

    F.write(str) 

    把str写到文件中,write()并不会在str后加上一个换行符

    F.writelines(seq) 

    把seq的内容全部写到文件中。这个函数也只是忠实地写入,不会在每行后面加上任何东西

    F.close() 

    关闭文件。python会在一个文件不用后自动关闭文件,不过这一功能没有保证,最好还是养成自己关闭的习惯。如果一个文件在关闭后还对其进行操作会产生ValueError 

    F.flush()

    把缓冲区的内容写入硬盘 ,即将内存中的数据刷新到银盘上

    F.fileno() 

    返回一个长整型的”文件标签“ 

    F.isatty()

    文件是否是一个终端设备文件(unix系统中的)

    F.tell() 

    返回文件操作标记的当前位置,以文件的开头为原点 

    F.next()

    返回下一行,并将文件操作标记位移到下一行。把一个file用于for ... in file这样的语句时,就是调用next()函数来实现遍历的。 

    F.seek(offset[,whence]) 

    将文件打操作标记移到offset的位置。这个offset一般是相对于文件的开头来计算的,一般为正数。但如果提供了whence参数就不一定了,whence可以为0表示从头开始计算,1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。需要注意,如果文件以a或a 的模式打开,每次进行写操作时,文件操作标记会自动返回到文件末尾

    F.truncate([size]) 

    把文件裁成规定的大小,默认的是裁到当前文件操作标记的位置。如果size比文件的大小还要大,依据系统的不同可能是不改变文件,也可能是用0把文件补到相应的大小,也可能是以一些随机的内容加上去。

    2. File对象的属性

    一个文件被打开后,你有一个file对象,你可以得到有关该文件的各种信息。

    以下是和file对象相关的所有属性的列表:

    file.closed 返回true如果文件已被关闭,否则返回false。
    file.mode 返回被打开文件的访问模式。
    file.name 返回文件的名称。
    file.softspace 如果用print输出后,必须跟一个空格符,则返回false。否则返回true。

     

     

     

     

     

    如下实例:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    
    # 打开一个文件
    fo = open("foo.txt", "wb")
    print "文件名: ", fo.name
    print "是否已关闭 : ", fo.closed
    print "访问模式 : ", fo.mode
    print "末尾是否强制加空格 : ", fo.softspace
    

    4. readlines()将每⼀⾏形成⼀个元素, 放到⼀个列表中. 将所有的内容都读取出来. 所以 也是. 容易出现内存崩溃的问题.不推荐使⽤

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

    打印第9行,不打印第10行示例

    法一:不推荐使用,效率太低

     1 #!/usr/bin/env python
     2 # -*- coding:utf-8 -*-
     3 #Author: nulige
     4 
     5 #打印第9行,不打印第10行
     6 f = open("yesterday2",'r',encoding="utf-8")
     7 for index, line in enumerate(f.readlines()):
     8     if index == 9:
     9         print('-----------我是分割线-----------')
    10         continue
    11     print(line.strip())
    

     

    法2: 推荐使用,效率高

     1 #!/usr/bin/env python
     2 # -*- coding:utf-8 -*-
     3 #Author: nulige
     4 
     5 #处理20G的文件,一行一行处理,内存中只占用一行的方法
     6 f = open("yesterday2",'r',encoding="utf-8")
     7 count = 0
     8 for line in f:
     9     if count == 9:
    10         print('-----------我是分割线-----------')
    11         count  = 1
    12         continue
    13     print(line.strip())
    14     count  =1
    

    执行结果:

     1 Somehow, it seems the love I knew was always the most destructive kind
     2 不知为何,我经历的爱情总是最具毁灭性的的那种
     3 Yesterday when I was young
     4 昨日当我年少轻狂
     5 The taste of life was sweet
     6 生命的滋味是甜的
     7 As rain upon my tongue
     8 就如舌尖上的雨露
     9 I teased at life as if it were a foolish game
    10 -----------我是分割线-----------     #没有打印第10行
    11 The way the evening breeze
    12 就如夜晚的微风
    13 May tease the candle flame
    14 逗弄蜡烛的火苗
    15 The thousand dreams I dreamed
    16 我曾千万次梦见
    17 The splendid things I planned
    18 那些我计划的绚丽蓝图
    19 I always built to last on weak and shifting sand
    20 但我总是将之建筑在易逝的流沙上
    21 I lived by night and shunned the naked light of day
    22 我夜夜笙歌 逃避白昼赤裸的阳光
    23 And only now I see how the time ran away
    24 事到如今我才看清岁月是如何匆匆流逝
    25 Yesterday when I was young
    26 昨日当我年少轻狂
    27 So many lovely songs were waiting to be sung
    28 有那么多甜美的曲儿等我歌唱
    29 So many wild pleasures lay in store for me
    30 有那么多肆意的快乐等我享受
    31 And so much pain my eyes refused to see
    32 还有那么多痛苦 我的双眼却视而不见
    33 I ran so fast that time and youth at last ran out
    34 我飞快地奔走 最终时光与青春消逝殆尽
    35 I never stopped to think what life was all about
    36 我从未停下脚步去思考生命的意义
    37 And every conversation that I can now recall
    38 如今回想起的所有对话
    39 Concerned itself with me and nothing else at all
    40 除了和我相关的 什么都记不得了
    41 The game of love I played with arrogance and pride
    42 我用自负和傲慢玩着爱情的游戏
    43 And every flame I lit too quickly, quickly died
    44 所有我点燃的火焰都熄灭得太快
    45 The friends I made all somehow seemed to slip away
    46 所有我交的朋友似乎都不知不觉地离开了
    47 And only now I'm left alone to end the play, yeah
    48 只剩我一个人在台上来结束这场闹剧
    49 Oh, yesterday when I was young
    50 噢 昨日当我年少轻狂
    51 So many, many songs were waiting to be sung
    52 有那么那么多甜美的曲儿等我歌唱
    53 So many wild pleasures lay in store for me
    54 有那么多肆意的快乐等我享受
    55 And so much pain my eyes refused to see
    56 还有那么多痛苦 我的双眼却视而不见
    57 There are so many songs in me that won't be sung
    58 我有太多歌曲永远不会被唱起
    59 I feel the bitter taste of tears upon my tongue
    60 我尝到了舌尖泪水的苦涩滋味
    61 The time has come for me to pay for yesterday
    62 终于到了付出代价的时间 为了昨日
    63 When I was young
    64 当我年少轻狂
    

     


     python文件操作 seek(),tell()

    seek():移动文件读取指针到指定位置

    tell():返回文件读取指针的位置

     

    ps:

     1 #!/usr/bin/env python
     2 # -*- coding:utf-8 -*-
     3 #Author: nulige
     4 
     5 f = open("yesterday2",'r',encoding="utf-8")
     6 print(f.tell())        #按字符计数
     7 #print(f.readline())   #按字符进行读取
     8 #print(f.read(5))      #只读5个字符
     9 print(f.readline())
    10 print(f.readline())
    11 print(f.readline())
    12 print(f.tell())
    13 
    14 #回到第几行,想回第几行,就输入数字几
    15 
    16 f.seek(0)    #回到第0行
    17 f.seek(10)   #回到第10行
    18 print(f.readline())
    

    执行结果:

    1 0
    2 Somehow, it seems the love I knew was always the most destructive kind
    3 
    4 不知为何,我经历的爱情总是最具毁灭性的的那种
    5 
    6 Yesterday when I was young
    7 
    8 168
    9 t seems the love I knew was always the most destructive kind    #从这行的前面位置开始读取
    

     

    encoding 打印文件编码

    1 #!/usr/bin/env python
    2 # -*- coding:utf-8 -*-
    3 #Author: nulige
    4 
    5 f = open("yesterday2",'r',encoding="utf-8")
    6 
    7 #打印文件编码
    8 print(f.encoding)
    

    执行结果:

    1 utf-8
    

     

    fileno() 返回文件句柄,在内存中的编号

    1 #!/usr/bin/env python
    2 # -*- coding:utf-8 -*-
    3 #Author: nulige
    4 
    5 f = open("yesterday2",'r',encoding="utf-8")
    6 
    7 #返回文件句柄,在内存中的编号
    8 print(f.fileno())
    

    执行结果:

    1 3
    

     

    name  打印文件名称

    1 #!/usr/bin/env python
    2 # -*- coding:utf-8 -*-
    3 #Author: nulige
    4 
    5 f = open("yesterday2",'r',encoding="utf-8")
    6 
    7 #打印文件名字
    8 print(f.name)
    

    执行结果:

    1 yesterday2
    

     

    isatty() 打印一个终端设备  (什么是终端设备呢,例如:打印机)

    结果只会显示:False or true

    1 #!/usr/bin/env python
    2 # -*- coding:utf-8 -*-
    3 #Author: nulige
    4 
    5 f = open("yesterday2",'r',encoding="utf-8")
    6 
    7 #打印一个终端设备(用于打印机交互)
    8 print(f.isatty())
    

    执行结果:

    1 False
    

     

    seekable  移动指针位置

    备注:

    # tty文件是不能移回去的,不是所有的都可以移回去的,只有字符串、二进制可以移回去。
    
    1 #!/usr/bin/env python
    2 # -*- coding:utf-8 -*-
    3 #Author: nulige
    4 
    5 f = open("yesterday2",'r',encoding="utf-8")
    6 
    7 # tty文件是不能移回去的,不是所有的都可以移回去的,只有字符串、二进制可以移回去。
    8 print(f.seekable)
    

    执行结果:

    1 <built-in method seekable of _io.TextIOWrapper object at 0x01437430>
    

     

    查看buffer

    1 #查看buffer  (本身buffer,也是内存中的临时文件)
    2 print(dir(f.buffer) )
    

    执果:

    1 ['__class__', '__del__', '__delattr__', '__dict__', '__dir__', '__doc__', '__enter__', '__eq__', '__exit__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__lt__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_checkClosed', '_checkReadable', '_checkSeekable', '_checkWritable', '_dealloc_warn', '_finalizing', 'close', 'closed', 'detach', 'fileno', 'flush', 'isatty', 'mode', 'name', 'peek', 'raw', 'read', 'read1', 'readable', 'readinto', 'readinto1', 'readline', 'readlines', 'seek', 'seekable', 'tell', 'truncate', 'writable', 'write', 'writelines']
    

     

    flush 刷新 

    说明:写入的内容是存放在电脑的缓存中的,只有flush了一下,才会保存到硬盘中去。

    #刚写完一行内容,如果断电,他就没有写进去,断电内存中数据就会丢失。如果没有断电,数据还在内存的缓存中,需要刷新一下,才能写到硬盘中。

    #内存有一个大小限制,需要达到这个大小,才会把内存缓存中的内容写到硬盘中。

    新葡亰496net 8

    新葡亰496net 9

     

    3.1 file的基本方法

    方法

    功能

    F.read([size])  

    size为读取的长度,以byte为单位

    F.readline([size]) 

    如果定义了size,有可能返回的只是一行的一部分 

    F.readlines([size]) 

    把文件每一行作为一个list的一个成员,并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数,size是表示读取内容的总长,也就是说可能只读到文件的一部分

    F.write(str) 

    把str写到文件中,write()并不会在str后加上一个换行符

    F.writelines(seq) 

    把seq的内容全部写到文件中。这个函数也只是忠实地写入,不会在每行后面加上任何东西

    F.close() 

    关闭文件。python会在一个文件不用后自动关闭文件,不过这一功能没有保证,最好还是养成自己关闭的习惯。如果一个文件在关闭后还对其进行操作会产生ValueError 

    F.flush()

    把缓冲区的内容写入硬盘 ,即将内存中的数据刷新到银盘上

    F.fileno() 

    返回一个长整型的”文件标签“ 

    F.isatty()

    文件是否是一个终端设备文件(unix系统中的)

    F.tell() 

    返回文件操作标记的当前位置,以文件的开头为原点 

    F.next()

    返回下一行,并将文件操作标记位移到下一行。把一个file用于for ... in file这样的语句时,就是调用next()函数来实现遍历的。 

    F.seek(offset[,whence]) 

    将文件打操作标记移到offset的位置。这个offset一般是相对于文件的开头来计算的,一般为正数。但如果提供了whence参数就不一定了,whence可以为0表示从头开始计算,1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。需要注意,如果文件以a或a 的模式打开,每次进行写操作时,文件操作标记会自动返回到文件末尾

    F.truncate([size]) 

    把文件裁成规定的大小,默认的是裁到当前文件操作标记的位置。如果size比文件的大小还要大,依据系统的不同可能是不改变文件,也可能是用0把文件补到相应的大小,也可能是以一些随机的内容加上去。如果没有指定 size,则从当前位置起截断;截断之后 size 后面的所有字符被删除。

     

    3. 文件操作函数

    class file(object):
    
        def close(self): # real signature unknown; restored from __doc__
            关闭文件
            """
            close() -> None or (perhaps) an integer.  Close the file.
    
            Sets data attribute .closed to True.  A closed file cannot be used for
            further I/O operations.  close() may be called more than once without
            error.  Some kinds of file objects (for example, opened by popen())
            may return an exit status upon closing.
            """
    
        def fileno(self): # real signature unknown; restored from __doc__
            文件描述符  
             """
            fileno() -> integer "file descriptor".
    
            This is needed for lower-level file interfaces, such os.read().
            """
            return 0    
    
        def flush(self): # real signature unknown; restored from __doc__
            刷新文件内部缓冲区
            """ flush() -> None.  Flush the internal I/O buffer. """
            pass
    
    
        def isatty(self): # real signature unknown; restored from __doc__
            判断文件是否是同意tty设备
            """ isatty() -> true or false.  True if the file is connected to a tty device. """
            return False
    
    
        def next(self): # real signature unknown; restored from __doc__
            获取下一行数据,不存在,则报错
            """ x.next() -> the next value, or raise StopIteration """
            pass
    
        def read(self, size=None): # real signature unknown; restored from __doc__
            读取指定字节数据
            """
            read([size]) -> read at most size bytes, returned as a string.
    
            If the size argument is negative or omitted, read until EOF is reached.
            Notice that when in non-blocking mode, less data than what was requested
            may be returned, even if no size parameter was given.
            """
            pass
    
        def readinto(self): # real signature unknown; restored from __doc__
            读取到缓冲区,不要用,将被遗弃
            """ readinto() -> Undocumented.  Don't use this; it may go away. """
            pass
    
        def readline(self, size=None): # real signature unknown; restored from __doc__
            仅读取一行数据
            """
            readline([size]) -> next line from the file, as a string.
    
            Retain newline.  A non-negative size argument limits the maximum
            number of bytes to return (an incomplete line may be returned then).
            Return an empty string at EOF.
            """
            pass
    
        def readlines(self, size=None): # real signature unknown; restored from __doc__
            读取所有数据,并根据换行保存值列表
            """
            readlines([size]) -> list of strings, each a line from the file.
    
            Call readline() repeatedly and return a list of the lines so read.
            The optional size argument, if given, is an approximate bound on the
            total number of bytes in the lines returned.
            """
            return []
    
        def seek(self, offset, whence=None): # real signature unknown; restored from __doc__
            指定文件中指针位置
            """
            seek(offset[, whence]) -> None.  Move to new file position.
    
            Argument offset is a byte count.  Optional argument whence defaults to
            0 (offset from start of file, offset should be >= 0); other values are 1
            (move relative to current position, positive or negative), and 2 (move
            relative to end of file, usually negative, although many platforms allow
            seeking beyond the end of a file).  If the file is opened in text mode,
            only offsets returned by tell() are legal.  Use of other offsets causes
            undefined behavior.
            Note that not all file objects are seekable.
            """
            pass
    
        def tell(self): # real signature unknown; restored from __doc__
            获取当前指针位置
            """ tell() -> current file position, an integer (may be a long integer). """
            pass
    
        def truncate(self, size=None): # real signature unknown; restored from __doc__
            截断数据,仅保留指定之前数据
            """
            truncate([size]) -> None.  Truncate the file to at most size bytes.
    
            Size defaults to the current file position, as returned by tell().
            """
            pass
    
        def write(self, p_str): # real signature unknown; restored from __doc__
            写内容
            """
            write(str) -> None.  Write string str to file.
    
            Note that due to buffering, flush() or close() may be needed before
            the file on disk reflects the data written.
            """
            pass
    
        def writelines(self, sequence_of_strings): # real signature unknown; restored from __doc__
            将一个字符串列表写入文件
            """
            writelines(sequence_of_strings) -> None.  Write the strings to the file.
    
            Note that newlines are not added.  The sequence can be any iterable object
            producing strings. This is equivalent to calling write() for each string.
            """
            pass
    
        def xreadlines(self): # real signature unknown; restored from __doc__
            可用于逐行读取文件,非全部
            """
            xreadlines() -> returns self.
    
            For backward compatibility. File objects now include the performance
            optimizations previously implemented in the xreadlines module.
            """
            pass
    

      

    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()
    

     在屏幕上面打印进度条

    法一:

     1 打印一个#号,每次都会换行
     2 >>>print("#")
     3 #
     4 >>>print("#")
     5 #
     6 >>>print("#")
     7 #
     8 
     9 那我们就不能用这种方法。需要用下面方法实现
    10 >>>import sys
    11 >>>sys.stdout.write(“#】”)    #标准输出。输出到屏幕。
    12 #12
    13 >>>sys.stdout.write(“####”)    
    14 ####4
    15 >>>sys.stdout.write(“########”)    
    16 ########8
    

     

    法二:

     1 #!/usr/bin/env python
     2 # -*- coding:utf-8 -*-      
     3 #Author: nulige
     4 
     5 import sys,time
     6 
     7 for i in range(50):
     8     sys.stdout.write("#")
     9     sys.stdout.flush()
    10     time.sleep(0.1)
    

    执行结果:

    1 ##################################################
    

     

    truncate 截断文件

    如果你不写,就会把文件清空

    1 #!/usr/bin/env python
    2 # -*- coding:utf-8 -*-      
    3 #Author: nulige
    4 
    5 f = open("yesterday2",'w',encoding="utf-8")
    6 f.truncate()   #注意 ()里面没有写内容,会把文件清空
    

    执行结果:

    yesterday2.txt 中文件内容被清空

    1 #!/usr/bin/env python
    2 # -*- coding:utf-8 -*-      
    3 #Author: nulige
    4 
    5 f = open("yesterday2",'a',encoding="utf-8")  #文件句柄
    6 f.truncate(10)
    

    执行结果:

    yesterday2.txt 中文件内容被清空

    1 Somehow, i
    

     

     

    3.2 文件的读取、创建、追加、删除、清空

    3.1 file(文件方法)

    •  以下是文件操作的常用方法
    1

    file.close()   关闭文件。关闭后文件不能再进行读写操作。

    2

    file.flush()   刷新文件内部缓冲,直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。

    3

    file.fileno()   返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。

    4

    file.isatty()   如果文件连接到一个终端设备返回 True,否则返回 False。

    5

    file.next()   返回文件下一行。

    6

    file.read([size])   从文件读取指定的字节数,如果未给定或为负则读取所有。

    7

    file.readline([size])    读取整行,包括 "n" 字符。

    8

    file.readlines([sizeint])    读取所有行并返回列表,若给定sizeint>0,返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。

    9

    file.seek(offset[, whence])   设置文件当前位置

    10

    file.tell()   返回文件当前位置。

    11

    file.truncate([size])     截取文件,截取的字节通过size指定,默认为当前文件位置。

    12

    file.write(str)    将字符串写入文件,没有返回值。

    13

    file.writelines(sequence)   向文件写入一个序列字符串列表,如果需要换行则要自己加入每行的换行符。

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    四. 追加(a, ab)

    在追加模式下. 我们写入的内容会追加在⽂件的结尾.

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

    ab模式⾃⼰试⼀试就好了

    移到第10位,截取20个字符

    1 #!/usr/bin/env python
    2 # -*- coding:utf-8 -*-      
    3 #Author: nulige
    4 
    5 f = open("yesterday2",'a',encoding="utf-8")  #文件句柄
    6 f.seek(10)
    7 f.truncate(20)
    

    执行结果:

    yesterday2.txt 中文件内容

    1 Somehow, it seems th
    

     


    " " 表示可以同时读写某个文件

    • r ,可读写文件。【可读;可写;可追加】
    • w ,写读
    • a ,同a

    "U"表示在读取时,可以将 r n rn自动转换成 n (与 r 或 r 模式同使用)

    • rU
    • r U

     

     

    r ,可读写文件。【可读;可写;可追加】 (工作中经常用)

     1 #!/usr/bin/env python
     2 # -*- coding:utf-8 -*-      
     3 #Author: nulige
     4 
     5 f = open("yesterday2",'r ',encoding="utf-8")  #文件句柄 ,读写
     6 print(f.readline())
     7 print(f.readline())
     8 print(f.readline())
     9 print(f.tell())    #打印光标
    10 f.write("------------------diao-------------------")
    
    11 print(f.readline())
    

    执行结果:

    1 Somehow, it seems the love I knew was always the most destructive kind
    2 
    3 不知为何,我经历的爱情总是最具毁灭性的的那种
    4 
    5 Yesterday when I was young
    6 
    7 168
    

    写入yesterday2文件中的内容

    新葡亰496net 10

     1 Somehow, it seems the love I knew was always the most destructive kind
     2 不知为何,我经历的爱情总是最具毁灭性的的那种
     3 Yesterday when I was young
     4 昨日当我年少轻狂
     5 The taste of life was sweet
     6 生命的滋味是甜的
     7 As rain upon my tongue
     8 就如舌尖上的雨露
     9 I teased at life as if it were a foolish game
    10 我戏弄生命 视其为愚蠢的游戏
    11 The way the evening breeze
    12 就如夜晚的微风
    13 May tease the candle flame
    14 逗弄蜡烛的火苗
    15 The thousand dreams I dreamed
    16 我曾千万次梦见
    17 The splendid things I planned
    18 那些我计划的绚丽蓝图
    19 I always built to last on weak and shifting sand
    20 但我总是将之建筑在易逝的流沙上
    21 I lived by night and shunned the naked light of day
    22 我夜夜笙歌 逃避白昼赤裸的阳光
    23 And only now I see how the time ran away
    24 事到如今我才看清岁月是如何匆匆流逝
    25 Yesterday when I was young
    26 昨日当我年少轻狂
    27 So many lovely songs were waiting to be sung
    28 有那么多甜美的曲儿等我歌唱
    29 So many wild pleasures lay in store for me
    30 有那么多肆意的快乐等我享受
    31 And so much pain my eyes refused to see
    32 还有那么多痛苦 我的双眼却视而不见
    33 I ran so fast that time and youth at last ran out
    34 我飞快地奔走 最终时光与青春消逝殆尽
    35 I never stopped to think what life was all about
    36 我从未停下脚步去思考生命的意义
    37 And every conversation that I can now recall
    38 如今回想起的所有对话
    39 Concerned itself with me and nothing else at all
    40 除了和我相关的 什么都记不得了
    41 The game of love I played with arrogance and pride
    42 我用自负和傲慢玩着爱情的游戏
    43 And every flame I lit too quickly, quickly died
    44 所有我点燃的火焰都熄灭得太快
    45 The friends I made all somehow seemed to slip away
    46 所有我交的朋友似乎都不知不觉地离开了
    47 And only now I'm left alone to end the play, yeah
    48 只剩我一个人在台上来结束这场闹剧
    49 Oh, yesterday when I was young
    50 噢 昨日当我年少轻狂
    51 So many, many songs were waiting to be sung
    52 有那么那么多甜美的曲儿等我歌唱
    53 So many wild pleasures lay in store for me
    54 有那么多肆意的快乐等我享受
    55 And so much pain my eyes refused to see
    56 还有那么多痛苦 我的双眼却视而不见
    57 There are so many songs in me that won't be sung
    58 我有太多歌曲永远不会被唱起
    59 I feel the bitter taste of tears upon my tongue
    60 我尝到了舌尖泪水的苦涩滋味
    61 The time has come for me to pay for yesterday
    62 终于到了付出代价的时间 为了昨日
    63 When I was young
    64 当我年少轻狂------------------diao-------------------
    

    View Code

     

    3.2 文件的读取、创建、追加、删除、清空

    一,用python创建一个新文件,内容是0到9的整数,每个数字占一行

    f = open('f.txt','w')
    for i in range(0,10):
        f.write(str(i) 'n')
    
    f.close()
    

    3.2 文件内置函数flush

    flush原理:

    1. 文件操作是通过软件将文件从硬盘读到内存。
    2. 写入文件的操作也都是存入内存缓冲区buffer(内存速度快于硬盘,如果写入文件的数据都从内存刷到硬盘,内存与硬盘的速度延迟会被无限放大,效率变低,所以要刷到硬盘的数据我们统一往内存的一小块空间即buffer中放,一段时间后操作系统会将buffer中数据一次性刷到硬盘)
    3. flush即,强制将写入的数据刷到硬盘。

    滚动条:

    import sys,time
    
    for i in  range(10):
        sys.stdout.write('#')
        sys.stdout.flush()
        time.sleep(0.2)
    

    五. 读写模式(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 模式下, ⼀开始读取不到数据. 然后写的时候再将原来 的内容清空. 所以, 很少⽤.

    w ,写读 (工作中基本不用)

    示例1:

     1 #!/usr/bin/env python
     2 # -*- coding:utf-8 -*-      
     3 #Author: nulige
     4 
     5 #f = open("yesterday2",'r ',encoding="utf-8")  #文件句柄
     6 f = open("yesterday2",'w ',encoding="utf-8")  #文件句柄
     7 print(f.readline())
     8 print(f.readline())
     9 print(f.readline())
    10 print(f.tell())    #打印光标
    11 f.write("------------------diao-------------------")
    12 print(f.readline())
    

    执行结果:

    往yesterday2文件中写入内容

    1 ------------------diao-------------------
    

     

    示例2:

     1 #!/usr/bin/env python
     2 # -*- coding:utf-8 -*-      
     3 #Author: nulige
     4 
     5 #f = open("yesterday2",'r ',encoding="utf-8")  #文件句柄
     6 f = open("yesterday2",'w ',encoding="utf-8")  #文件句柄
     7 
     8 #创建文件写4行
     9 f.write("------------------diao------------------1n")
    10 f.write("------------------diao------------------1n")
    11 f.write("------------------diao------------------1n")
    12 f.write("------------------diao------------------1n")
    13 
    14 #打印位置
    15 print(f.tell())
    16 
    17 #返回指针到第10行
    18 f.seek(10)
    19 
    20 #打印出来
    21 print(f.readline())
    22 
    23 #写入下面这句话
    24 f.write("should be at the begining of the second line")
    25 
    26 #关闭
    27 f.close()
    

    执行结果:

    1 ------------------diao------------------1
    2 ------------------diao------------------1    #没有办法在这行写,往前面写会不停覆盖原文件,要字符相等,否则会覆盖掉原文件。
    3 ------------------diao------------------1
    4 ------------------diao------------------1
    5 should be at the begining of the second line
    

     

    a ,同a

     1 #!/usr/bin/env python
     2 # -*- coding:utf-8 -*-      
     3 #Author: nulige
     4 
     5 #f = open("yesterday2",'r ',encoding="utf-8")  #文件句柄  读写
     6 #f = open("yesterday2",'w ',encoding="utf-8")  #文件句柄  写读
     7 f = open("yesterday2",'a ',encoding="utf-8")  #文件句柄  追加读写
     8 #创建文件写4行
     9 f.write("------------------diao------------------1n")
    10 f.write("------------------diao------------------1n")
    11 f.write("------------------diao------------------1n")
    12 f.write("------------------diao------------------1n")
    13 #打印位置
    14 print(f.tell())
    15 #返回指针到第10行
    16 f.seek(10)
    17 #打印出来
    18 print(f.readline())
    19 #写入下面这句话
    20 f.write("should be at the begining of the second line")
    21 #关闭
    22 f.close()
    

    执行结果:

    1 ------------------diao------------------1
    2 ------------------diao------------------1
    3 ------------------diao------------------1
    4 ------------------diao------------------1
    5 should be at the begining of the second line
    

     


     

    "b"表示处理二进制文件(如:FTP发送上传ISO镜像文件,linux可忽略,windows处理二进制文件时需标注)

    • rb
    • wb
    • ab

     

    打开二进制文件(网络传输的时候,就必须以二进制打开)

    1 #!/usr/bin/env python
    2 # -*- coding:utf-8 -*-      
    3 #Author: nulige
    4 
    5 f = open("yesterday2",'rb')  #文件句柄  二进制文件
    6 print(f.readline())
    7 print(f.readline())
    8 print(f.readline())
    

    执行结果:

    1 b'------------------diao------------------1rn'
    2 b'------------------diao------------------1rn'
    3 b'------------------diao------------------1rn'
    

     

    文件操作的二进制读写

    1 #!/usr/bin/env python
    2 # -*- coding:utf-8 -*-      
    3 #Author: nulige
    4 
    5 f = open("yesterday2",'wb')  #文件句柄  二进制文件
    6 f.write("hello binaryn".encode())
    7 f.close()
    

    执行结果:

    1 hello binary
    

     


     

    更改文件内容

     

    1、先创建一个yesterday2的文件,内容如下:

     1 Somehow, it seems the love I knew was always the most destructive kind
     2 不知为何,我经历的爱情总是最具毁灭性的的那种
     3 Yesterday when I was young
     4 昨日当我年少轻狂
     5 The taste of life was sweet
     6 生命的滋味是甜的
     7 As rain upon my tongue
     8 就如舌尖上的雨露
     9 I teased at life as if it were a foolish game
    10 我戏弄生命 视其为愚蠢的游戏
    11 The way the evening breeze
    12 就如夜晚的微风
    13 May tease the candle flame
    14 逗弄蜡烛的火苗
    15 The thousand dreams I dreamed
    16 我曾千万次梦见
    17 The splendid things I planned
    18 那些我计划的绚丽蓝图
    19 I always built to last on weak and shifting sand
    20 但我总是将之建筑在易逝的流沙上
    21 I lived by night and shunned the naked light of day
    22 我夜夜笙歌 逃避白昼赤裸的阳光
    23 And only now I see how the time ran away
    24 事到如今我才看清岁月是如何匆匆流逝
    25 Yesterday when I was young
    26 昨日当我年少轻狂
    27 So many lovely songs were waiting to be sung
    28 有那么多甜美的曲儿等我歌唱
    29 So many wild pleasures lay in store for me
    30 有那么多肆意的快乐等我享受
    31 And so much pain my eyes refused to see
    32 还有那么多痛苦 我的双眼却视而不见
    33 I ran so fast that time and youth at last ran out
    34 我飞快地奔走 最终时光与青春消逝殆尽
    35 I never stopped to think what life was all about
    36 我从未停下脚步去思考生命的意义
    37 And every conversation that I can now recall
    38 如今回想起的所有对话
    39 Concerned itself with me and nothing else at all
    40 除了和我相关的 什么都记不得了
    41 The game of love I played with arrogance and pride
    42 我用自负和傲慢玩着爱情的游戏
    43 And every flame I lit too quickly, quickly died
    44 所有我点燃的火焰都熄灭得太快
    45 The friends I made all somehow seemed to slip away
    46 所有我交的朋友似乎都不知不觉地离开了
    47 And only now I'm left alone to end the play, yeah
    48 只剩我一个人在台上来结束这场闹剧
    49 Oh, yesterday when I was young
    50 噢 昨日当我年少轻狂
    51 So many, many songs were waiting to be sung
    52 有那么那么多甜美的曲儿等我歌唱
    53 So many wild pleasures lay in store for me
    54 有那么多肆意的快乐等我享受
    55 And so much pain my eyes refused to see
    56 还有那么多痛苦 我的双眼却视而不见
    57 There are so many songs in me that won't be sung
    58 我有太多歌曲永远不会被唱起
    59 I feel the bitter taste of tears upon my tongue
    60 我尝到了舌尖泪水的苦涩滋味
    61 The time has come for me to pay for yesterday
    62 终于到了付出代价的时间 为了昨日
    63 When I was young
    64 当我年少轻狂
    

     

    2、先创建一个新文件,再读取文件内容,再更改其中某一行内容

     1 #!/usr/bin/env python
     2 # -*- coding:utf-8 -*-
     3 #Author: nulige
     4 
     5 #先读取,再写入一行
     6 f = open("yesterday2",'r',encoding="utf-8")
     7 f_new = open("yesterday2.bak",'w',encoding="utf-8")
     8 
     9 for line in f:
    10     if "肆意的快乐等我享受" in line:
    11         line =line.replace("肆意的快乐等我享受","肆意的快乐等Alex享受")
    12     f_new.write(line)
    13 f.close()
    14 f_new.close()
    

     

    执行结果:

    会先创建一个 yesterday2.bak的文件,再更改其中某一行内容

     1 Somehow, it seems the love I knew was always the most destructive kind
     2 不知为何,我经历的爱情总是最具毁灭性的的那种
     3 Yesterday when I was young
     4 昨日当我年少轻狂
     5 The taste of life was sweet
     6 生命的滋味是甜的
     7 As rain upon my tongue
     8 就如舌尖上的雨露
     9 I teased at life as if it were a foolish game
    10 我戏弄生命 视其为愚蠢的游戏
    11 The way the evening breeze
    12 就如夜晚的微风
    13 May tease the candle flame
    14 逗弄蜡烛的火苗
    15 The thousand dreams I dreamed
    16 我曾千万次梦见
    17 The splendid things I planned
    18 那些我计划的绚丽蓝图
    19 I always built to last on weak and shifting sand
    20 但我总是将之建筑在易逝的流沙上
    21 I lived by night and shunned the naked light of day
    22 我夜夜笙歌 逃避白昼赤裸的阳光
    23 And only now I see how the time ran away
    24 事到如今我才看清岁月是如何匆匆流逝
    25 Yesterday when I was young
    26 昨日当我年少轻狂
    27 So many lovely songs were waiting to be sung
    28 有那么多甜美的曲儿等我歌唱
    29 So many wild pleasures lay in store for me
    30 有那么多肆意的快乐等Alex享受
    31 And so much pain my eyes refused to see
    32 还有那么多痛苦 我的双眼却视而不见
    33 I ran so fast that time and youth at last ran out
    34 我飞快地奔走 最终时光与青春消逝殆尽
    35 I never stopped to think what life was all about
    36 我从未停下脚步去思考生命的意义
    37 And every conversation that I can now recall
    38 如今回想起的所有对话
    39 Concerned itself with me and nothing else at all
    40 除了和我相关的 什么都记不得了
    41 The game of love I played with arrogance and pride
    42 我用自负和傲慢玩着爱情的游戏
    43 And every flame I lit too quickly, quickly died
    44 所有我点燃的火焰都熄灭得太快
    45 The friends I made all somehow seemed to slip away
    46 所有我交的朋友似乎都不知不觉地离开了
    47 And only now I'm left alone to end the play, yeah
    48 只剩我一个人在台上来结束这场闹剧
    49 Oh, yesterday when I was young
    50 噢 昨日当我年少轻狂
    51 So many, many songs were waiting to be sung
    52 有那么那么多甜美的曲儿等我歌唱
    53 So many wild pleasures lay in store for me
    54 有那么多肆意的快乐等Alex享受
    55 And so much pain my eyes refused to see
    56 还有那么多痛苦 我的双眼却视而不见
    57 There are so many songs in me that won't be sung
    58 我有太多歌曲永远不会被唱起
    59 I feel the bitter taste of tears upon my tongue
    60 我尝到了舌尖泪水的苦涩滋味
    61 The time has come for me to pay for yesterday
    62 终于到了付出代价的时间 为了昨日
    63 When I was young
    64 当我年少轻狂
    

     

    通过变量传参的方式,实现修改文件某行内容

     1 #!/usr/bin/env python
     2 # -*- coding:utf-8 -*-
     3 #Author: nulige
     4 
     5 import sys
     6 #先读取,再写入一行
     7 f = open("yesterday2",'r',encoding="utf-8")
     8 f_new = open("yesterday2.bak",'w',encoding="utf-8")
     9 
    10 find_str = sys.argv[1]
    11 replace_str = sys.argv[2]
    12 for line in f:
    13      if find_str in line:
    14         line = line.replace(find_str,replace_str)
    15      f_new.write(line)
    16 f.close()
    17 f_new.close()
    

     


    with语句

    为了避免打开文件后忘记关闭,可以通过管理上下文,即:

    1 with open('log','r') as f:
    2      
    3     ...
    

    如此方式,当with代码块执行完毕时,内部会自动关闭并释放文件资源。

    在Python 2.7 后,with又支持同时对多个文件的上下文进行管理,即:

    1 1
    2 2
    3 with open('log1') as obj1, open('log2') as obj2:
    4     pass
    

     

    ps:

    为了避免打开文件后忘记关闭,不用再写关闭语句,自动会帮你关闭。

    1、yesterday2文件内容

    新葡亰496net 11

     1 Somehow, it seems the love I knew was always the most destructive kind
     2 不知为何,我经历的爱情总是最具毁灭性的的那种
     3 Yesterday when I was young
     4 昨日当我年少轻狂
     5 The taste of life was sweet
     6 生命的滋味是甜的
     7 As rain upon my tongue
     8 就如舌尖上的雨露
     9 I teased at life as if it were a foolish game
    10 我戏弄生命 视其为愚蠢的游戏
    11 The way the evening breeze
    12 就如夜晚的微风
    13 May tease the candle flame
    14 逗弄蜡烛的火苗
    15 The thousand dreams I dreamed
    16 我曾千万次梦见
    17 The splendid things I planned
    18 那些我计划的绚丽蓝图
    19 I always built to last on weak and shifting sand
    20 但我总是将之建筑在易逝的流沙上
    21 I lived by night and shunned the naked light of day
    22 我夜夜笙歌 逃避白昼赤裸的阳光
    23 And only now I see how the time ran away
    24 事到如今我才看清岁月是如何匆匆流逝
    25 Yesterday when I was young
    26 昨日当我年少轻狂
    27 So many lovely songs were waiting to be sung
    28 有那么多甜美的曲儿等我歌唱
    29 So many wild pleasures lay in store for me
    30 有那么多肆意的快乐等我享受
    31 And so much pain my eyes refused to see
    32 还有那么多痛苦 我的双眼却视而不见
    33 I ran so fast that time and youth at last ran out
    34 我飞快地奔走 最终时光与青春消逝殆尽
    35 I never stopped to think what life was all about
    36 我从未停下脚步去思考生命的意义
    37 And every conversation that I can now recall
    38 如今回想起的所有对话
    39 Concerned itself with me and nothing else at all
    40 除了和我相关的 什么都记不得了
    41 The game of love I played with arrogance and pride
    42 我用自负和傲慢玩着爱情的游戏
    43 And every flame I lit too quickly, quickly died
    44 所有我点燃的火焰都熄灭得太快
    45 The friends I made all somehow seemed to slip away
    46 所有我交的朋友似乎都不知不觉地离开了
    47 And only now I'm left alone to end the play, yeah
    48 只剩我一个人在台上来结束这场闹剧
    49 Oh, yesterday when I was young
    50 噢 昨日当我年少轻狂
    51 So many, many songs were waiting to be sung
    52 有那么那么多甜美的曲儿等我歌唱
    53 So many wild pleasures lay in store for me
    54 有那么多肆意的快乐等我享受
    55 And so much pain my eyes refused to see
    56 还有那么多痛苦 我的双眼却视而不见
    57 There are so many songs in me that won't be sung
    58 我有太多歌曲永远不会被唱起
    59 I feel the bitter taste of tears upon my tongue
    60 我尝到了舌尖泪水的苦涩滋味
    61 The time has come for me to pay for yesterday
    62 终于到了付出代价的时间 为了昨日
    63 When I was young
    64 当我年少轻狂
    

    View Code

    2、用with语句实现,文件自动关闭

     1 #!/usr/bin/env python
     2 # -*- coding:utf-8 -*-      
     3 #Author: nulige
     4 
     5 import sys
     6 #先读取,再写入一行
     7 # f = open("yesterday2",'r',encoding="utf-8")
     8 
     9 with open("yesterday2",'r',encoding="utf-8") as f:
    10     for line in f:
    11         print(line)
    

    执行结果:

    新葡亰496net 12

      1 Somehow, it seems the love I knew was always the most destructive kind
      2 
      3 不知为何,我经历的爱情总是最具毁灭性的的那种
      4 
      5 Yesterday when I was young
      6 
      7 昨日当我年少轻狂
      8 
      9 The taste of life was sweet
     10 
     11 生命的滋味是甜的
     12 
     13 As rain upon my tongue
     14 
     15 就如舌尖上的雨露
     16 
     17 I teased at life as if it were a foolish game
     18 
     19 我戏弄生命 视其为愚蠢的游戏
     20 
     21 The way the evening breeze
     22 
     23 就如夜晚的微风
     24 
     25 May tease the candle flame
     26 
     27 逗弄蜡烛的火苗
     28 
     29 The thousand dreams I dreamed
     30 
     31 我曾千万次梦见
     32 
     33 The splendid things I planned
     34 
     35 那些我计划的绚丽蓝图
     36 
     37 I always built to last on weak and shifting sand
     38 
     39 但我总是将之建筑在易逝的流沙上
     40 
     41 I lived by night and shunned the naked light of day
     42 
     43 我夜夜笙歌 逃避白昼赤裸的阳光
     44 
     45 And only now I see how the time ran away
     46 
     47 事到如今我才看清岁月是如何匆匆流逝
     48 
     49 Yesterday when I was young
     50 
     51 昨日当我年少轻狂
     52 
     53 So many lovely songs were waiting to be sung
     54 
     55 有那么多甜美的曲儿等我歌唱
     56 
     57 So many wild pleasures lay in store for me
     58 
     59 有那么多肆意的快乐等我享受
     60 
     61 And so much pain my eyes refused to see
     62 
     63 还有那么多痛苦 我的双眼却视而不见
     64 
     65 I ran so fast that time and youth at last ran out
     66 
     67 我飞快地奔走 最终时光与青春消逝殆尽
     68 
     69 I never stopped to think what life was all about
     70 
     71 我从未停下脚步去思考生命的意义
     72 
     73 And every conversation that I can now recall
     74 
     75 如今回想起的所有对话
     76 
     77 Concerned itself with me and nothing else at all
     78 
     79 除了和我相关的 什么都记不得了
     80 
     81 The game of love I played with arrogance and pride
     82 
     83 我用自负和傲慢玩着爱情的游戏
     84 
     85 And every flame I lit too quickly, quickly died
     86 
     87 所有我点燃的火焰都熄灭得太快
     88 
     89 The friends I made all somehow seemed to slip away
     90 
     91 所有我交的朋友似乎都不知不觉地离开了
     92 
     93 And only now I'm left alone to end the play, yeah
     94 
     95 只剩我一个人在台上来结束这场闹剧
     96 
     97 Oh, yesterday when I was young
     98 
     99 噢 昨日当我年少轻狂
    100 
    101 So many, many songs were waiting to be sung
    102 
    103 有那么那么多甜美的曲儿等我歌唱
    104 
    105 So many wild pleasures lay in store for me
    106 
    107 有那么多肆意的快乐等我享受
    108 
    109 And so much pain my eyes refused to see
    110 
    111 还有那么多痛苦 我的双眼却视而不见
    112 
    113 There are so many songs in me that won't be sung
    114 
    115 我有太多歌曲永远不会被唱起
    116 
    117 I feel the bitter taste of tears upon my tongue
    118 
    119 我尝到了舌尖泪水的苦涩滋味
    120 
    121 The time has come for me to pay for yesterday
    122 
    123 终于到了付出代价的时间 为了昨日
    124 
    125 When I was young
    126 
    127 当我年少轻狂
    

    View Code

     

    同时打开多个文件的写法

     1 #!/usr/bin/env python
     2 # -*- coding:utf-8 -*-      
     3 #Author: nulige
     4 
     5 import sys
     6 #先读取,再写入一行
     7 # f = open("yesterday2",'r',encoding="utf-8")
     8 
     9 with open("yesterday2",'r',encoding="utf-8") as f ,
    10         open("yesterday2", 'r', encoding="utf-8") as f2:
    11     for line in f:
    12         print(line)
    

    执行结果:

    新葡亰496net 13

      1 Somehow, it seems the love I knew was always the most destructive kind
      2 
      3 不知为何,我经历的爱情总是最具毁灭性的的那种
      4 
      5 Yesterday when I was young
      6 
      7 昨日当我年少轻狂
      8 
      9 The taste of life was sweet
     10 
     11 生命的滋味是甜的
     12 
     13 As rain upon my tongue
     14 
     15 就如舌尖上的雨露
     16 
     17 I teased at life as if it were a foolish game
     18 
     19 我戏弄生命 视其为愚蠢的游戏
     20 
     21 The way the evening breeze
     22 
     23 就如夜晚的微风
     24 
     25 May tease the candle flame
     26 
     27 逗弄蜡烛的火苗
     28 
     29 The thousand dreams I dreamed
     30 
     31 我曾千万次梦见
     32 
     33 The splendid things I planned
     34 
     35 那些我计划的绚丽蓝图
     36 
     37 I always built to last on weak and shifting sand
     38 
     39 但我总是将之建筑在易逝的流沙上
     40 
     41 I lived by night and shunned the naked light of day
     42 
     43 我夜夜笙歌 逃避白昼赤裸的阳光
     44 
     45 And only now I see how the time ran away
     46 
     47 事到如今我才看清岁月是如何匆匆流逝
     48 
     49 Yesterday when I was young
     50 
     51 昨日当我年少轻狂
     52 
     53 So many lovely songs were waiting to be sung
     54 
     55 有那么多甜美的曲儿等我歌唱
     56 
     57 So many wild pleasures lay in store for me
     58 
     59 有那么多肆意的快乐等我享受
     60 
     61 And so much pain my eyes refused to see
     62 
     63 还有那么多痛苦 我的双眼却视而不见
     64 
     65 I ran so fast that time and youth at last ran out
     66 
     67 我飞快地奔走 最终时光与青春消逝殆尽
     68 
     69 I never stopped to think what life was all about
     70 
     71 我从未停下脚步去思考生命的意义
     72 
     73 And every conversation that I can now recall
     74 
     75 如今回想起的所有对话
     76 
     77 Concerned itself with me and nothing else at all
     78 
     79 除了和我相关的 什么都记不得了
     80 
     81 The game of love I played with arrogance and pride
     82 
     83 我用自负和傲慢玩着爱情的游戏
     84 
     85 And every flame I lit too quickly, quickly died
     86 
     87 所有我点燃的火焰都熄灭得太快
     88 
     89 The friends I made all somehow seemed to slip away
     90 
     91 所有我交的朋友似乎都不知不觉地离开了
     92 
     93 And only now I'm left alone to end the play, yeah
     94 
     95 只剩我一个人在台上来结束这场闹剧
     96 
     97 Oh, yesterday when I was young
     98 
     99 噢 昨日当我年少轻狂
    100 
    101 So many, many songs were waiting to be sung
    102 
    103 有那么那么多甜美的曲儿等我歌唱
    104 
    105 So many wild pleasures lay in store for me
    106 
    107 有那么多肆意的快乐等我享受
    108 
    109 And so much pain my eyes refused to see
    110 
    111 还有那么多痛苦 我的双眼却视而不见
    112 
    113 There are so many songs in me that won't be sung
    114 
    115 我有太多歌曲永远不会被唱起
    116 
    117 I feel the bitter taste of tears upon my tongue
    118 
    119 我尝到了舌尖泪水的苦涩滋味
    120 
    121 The time has come for me to pay for yesterday
    122 
    123 终于到了付出代价的时间 为了昨日
    124 
    125 When I was young
    126 
    127 当我年少轻狂
    

    View Code

     


    一、读取大文件的最后一行内容(例如:查看linux系统文件日志)
    

     1、先创建一个日志文件

    内容如下:

    1 2016/12/25 alex 干了什么事情
    2 2016/12/26 alex 干了什么事情
    3 2016/12/27 alex 干了什么事情
    4 2016/12/28 alex 干了什么事情
    5 2016/12/29 alex 干了什么事情
    6 2016/12/30  sb  干了什么sb事情
    

     

    2、实现读取文件最后一行内容

     1 f = open('日志文件', 'rb')
     2 
     3 for i in f:
     4     offs = -10
     5     while True:
     6         f.seek(offs,2)  # 从最后一行往前找
     7         data = f.readlines()  # 一行一行找
     8         if len(data) > 1:
     9             print('文件的最后一行是:%s' % (data[-1].decode('utf-8')))  # 读取文件最后一行
    10             break
    11         offs *= 2    #相当于两倍文件的内容中查找
    

    执行结果:

    1 文件的最后一行是:2016/12/30  sb  干了什么sb事情
    

     

    一、文件操作 打开文件时,需要指定文件路径和以何等方式打开文件,打开后,即可获取该文件句柄,日后通过此文...

    一,用python创建一个新文件,内容是0到9的整数,每个数字占一行

    f = open('f.txt','w')
    for i in range(0,10):
        f.write(str(i) 'n')
    
    f.close()
    

    二,文件内容追加,从0到9的10个随机整数

    import random
    f = open('f.txt','a')
    for i in range(0,10):
        f.write(str(random.randint(0,9)))
    f.write('n')
    f.close()
    

    3.3 文件光标移动

    tell()方法告诉你文件内的当前位置;换句话说,下一次的读写会发生在文件开头这么多字节之后。

    seek(offset [,from])方法改变当前文件的位置。Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。

    如果from被设为0,这意味着将文件的开头作为移动字节的参考位置。如果设为1,则使用当前的位置作为参考位置。如果它被设为2,那么该文件的末尾将作为参考位置。

    seek():移动文件读取指针到指定位置,设置文件当前位置。

    tell():返回文件读取指针的位置。

    seek()的三种模式:

        (1)f.seek(p,0)  移动当文件第p个字节处,绝对位置

        (2)f.seek(p,1)  移动到相对于当前位置之后的p个字节

        (3)f.seek(p,2)  移动到相对文章尾之后的p个字节

    例子:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    
    # 打开一个文件
    fo = open("foo.txt", "r ")
    str = fo.read(10);
    print "读取的字符串是 : ", str
    
    # 查找当前位置
    position = fo.tell();
    print "当前文件位置 : ", position
    
    # 把指针再次重新定位到文件开头
    position = fo.seek(0, 0);
    str = fo.read(10);
    print "重新读取字符串 : ", str
    # 关闭打开的文件
    fo.close()
    

    注:read(3)代表读取3个字符,其余的文件内光标移动都是以字节为单位如seek,tell,read,truncate

     

    七. 追加读

    (a ) a 模式下, 不论先读还是后读. 都是读取不到数据的.

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

    还有⼀些其他的带b的操作. 就不多赘述了. 就是把字符换成字节. 仅此⽽已

    二,文件内容追加,从0到9的10个随机整数

    import random
    f = open('f.txt','a')
    for i in range(0,10):
        f.write(str(random.randint(0,9)))
    f.write('n')
    f.close()
    

    三、文件内容追加,从0到9的随机整数, 10个数字一行,共10行

    import random
    f = open('f.txt','a')
    for i in range(0,10):
        for i in range(0,10):
            f.write(str(random.randint(0,9)))
        f.write('n')
    f.close()
    

    3.4 open函数详解

    1. open()语法
    open(file[, mode[, buffering[, encoding[, errors[, newline[, closefd=True]]]]]])
    open函数有很多的参数,常用的是file,mode和encoding
    file文件位置,需要加引号
    mode文件打开模式,见下面3
    buffering的可取值有0,1,>1三个,0代表buffer关闭(只适用于二进制模式),1代表line buffer(只适用于文本模式),>1表示初始化的buffer大小;
    encoding表示的是返回的数据采用何种编码,一般采用utf8或者gbk;
    errors的取值一般有strict,ignore,当取strict的时候,字符编码出现问题的时候,会报错,当取ignore的时候,编码出现问题,程序会忽略而过,继续执行下面的程序。
    newline可以取的值有None, n, r, ”, ‘rn',用于区分换行符,但是这个参数只对文本模式有效;
    closefd的取值,是与传入的文件参数有关,默认情况下为True,传入的file参数为文件的文件名,取值为False的时候,file只能是文件描述符,什么是文件描述符,就是一个非负整数,在Unix内核的系统中,打开一个文件,便会返回一个文件描述符。

    八. 其他相关操作

    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()
    

    三、文件内容追加,从0到9的随机整数, 10个数字一行,共10行

    import random
    f = open('f.txt','a')
    for i in range(0,10):
        for i in range(0,10):
            f.write(str(random.randint(0,9)))
        f.write('n')
    f.close()
    

    四、把标准输出定向到文件

    import sys
    sys.stdout = open('stdout.txt','w')
    

    2. Python中file()与open()区别

    两者都能够打开文件,对文件进行操作,也具有相似的用法和参数,但是,这两种文件打开方式有本质的区别,file为文件类,用file()来打开文件,相当于这是在构造文件类,而用open()打开文件,是用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()
    

    四、把标准输出定向到文件

    import sys
    sys.stdout = open('stdout.txt','w')
    

    五,文件的读写

    5.1,文件打开

    f = file(name[, mode[, buffering]])
    name 文件名
    
    mode   选项,字符串
    
    buffering   是否缓冲 (0=不缓冲,1=缓冲, >1的int数=缓冲区大小) 
    

    3. 参数mode的基本取值

    Character Meaning
    ‘r' open for reading (default)
    ‘w' open for writing, truncating the file first
    ‘a' open for writing, appending to the end of the file if it exists
    ‘b' binary mode
    ‘t' text mode (default)
    ‘ ' open a disk file for updating (reading and writing)
    ‘U' universal newline mode (for backwards compatibility; should not be used in new code)

     

     

     

     

     

     

     

     

    r、w、a为打开文件的基本模式,对应着只读、只写、追加模式;

    b、t、 、U这四个字符,与以上的文件打开模式组合使用,二进制模式,文本模式,读写模式、通用换行符,根据实际情况组合使用;

    r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
    rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
    r 打开一个文件用于读写。文件指针将会放在文件的开头。
    rb 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
    w 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。
    wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。
    w 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。
    wb 以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。
    a 打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
    ab 以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
    a 打开一个文件用于读写。如果该文件已存在,文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在,创建新文件用于读写。
    ab 以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。如果该文件不存在,创建新文件用于读写。

     

     

     

     

     

     

     

     

     

     

     

    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, 则从当前位置截断. 后⾯ 的内容将会被删除

     

    五,文件的读写

    5.1,文件打开

    f = file(name[, mode[, buffering]])
    name 文件名
    
    mode   选项,字符串
    
    buffering   是否缓冲 (0=不缓冲,1=缓冲, >1的int数=缓冲区大小) 
    

    文件的读写属性

      file对象有自己的属性和方法。先来看看file的属性。( 和b可以和其他的字符组合成mode,例如rb以二进制只读方式打开,mode参数是可选的,如果没有默认为r)

    (注意:文件打开之后,应当被及时关闭,可以查看f.closed属性以确认文件是否被关闭)

    mode

    function

    r

    只读模式(默认,文件不存在,则发生异常)文件的指针将会放在文件的开头

    w

    只写模式(可读,文件不存在则创建,存在则删除内容,再打开文件)

    a

    追加模式(只能写,文件不存在则创建,存在则追加内容)

    r

    可读写模式(可读,可写,可追加)

    b

    以二进制方式打开(如:FTP发送上传ISO镜像文件,linux可忽略,windows处理二进制文件时需标注)

    w

    先写再读(可读,可写,可追加) 如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。

    a

    同a(可读可写,文件不存在则创建,存在则追加内容)。如果该文件已存在,文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在,创建新文件用于读写。

    rb

    以二进制读方式打开,只能读文件 , 如果文件不存在,会发生异常

    wb

    以二进制写方式打开,只能写文件, 如果文件不存在,创建该文件

    ab

    二进制追写文件。 从文件顶部读取内容 从文件底部添加内容 不存在则创建

    rt

    以文本读方式打开,只能读文件 , 如果文件不存在,会发生异常

    wt

    以文本写方式打开,只能读文件 , 如果文件不存在,创建该文件。如果文件存在。先清空,再打开文件

    at

    以文本读写方式打开,只能读文件 , 如果文件不存在,创建该文件。如果文件存在。先清空,再打开文件

    rb

    以二进制读方式打开,可以读、写文件 , 如果文件不存在,会发生异常  

    wb

    以二进制写方式打开,可以读、写文件, 如果文件不存在,创建该文件.如果文件存在。先清空,再打开文件

    ab

    追读写二进制。从文件顶部读取内容 从文件底部添加内容 不存在则创建

    5.2,关闭文件

    f.close()
    

      当文件读写完毕后,应关闭文件

    4. 常见的mode取值组合

    r或rt 默认模式,文本模式读
    rb   二进制文件
    
    w或wt 文本模式写,打开前文件存储被清空
    wb  二进制写,文件存储同样被清空
    
    a  追加模式,只能写在文件末尾
    a  可读写模式,写只能写在文件末尾
    
    w  可读写,与a 的区别是要清空文件内容
    r  可读写,与a 的区别是可以写到文件任何位置
    

    九. 修改⽂件以及另⼀种打开⽂件的⽅式

    ⽂件修改: 只能将⽂件中的内容读取到内存中, 将信息修改完毕, 然后将源⽂件删除, 将新 ⽂件的名字改成老⽂件的名字.

    # ⽂件修改
    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)
    

     

    文件的读写属性

      file对象有自己的属性和方法。先来看看file的属性。( 和b可以和其他的字符组合成mode,例如rb以二进制只读方式打开,mode参数是可选的,如果没有默认为r)

    (注意:文件打开之后,应当被及时关闭,可以查看f.closed属性以确认文件是否被关闭)

    mode

    function

    r

    只读模式(默认,文件不存在,则发生异常)文件的指针将会放在文件的开头

    w

    只写模式(可读,文件不存在则创建,存在则删除内容,再打开文件)

    a

    追加模式(只能写,文件不存在则创建,存在则追加内容)

    r

    可读写模式(可读,可写,可追加),如果文件存在,则覆盖当前文件指针所在位置的字符,如原来文件内容是"Hello,World",打开文件后写入"hi"则文件内容会变成"hillo, World"

    b

    以二进制方式打开(如:FTP发送上传ISO镜像文件,linux可忽略,windows处理二进制文件时需标注)

    w

    先写再读(可读,可写,可追加) 如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。

    a

    同a(可读可写,文件不存在则创建,存在则追加内容)。如果该文件已存在,文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在,创建新文件用于读写。

    rb

    以二进制读方式打开,只能读文件 , 如果文件不存在,会发生异常

    wb

    以二进制写方式打开,只能写文件, 如果文件不存在,创建该文件

    ab

    二进制追写文件。 从文件顶部读取内容 从文件底部添加内容 不存在则创建

    rt

    以文本读方式打开,只能读文件 , 如果文件不存在,会发生异常

    wt

    以文本写方式打开,只能读文件 , 如果文件不存在,创建该文件。如果文件存在。先清空,再打开文件

    at

    以文本读写方式打开,只能读文件 , 如果文件不存在,创建该文件。如果文件存在。先清空,再打开文件

    rb

    以二进制读方式打开,可以读、写文件 , 如果文件不存在,会发生异常  

    wb

    以二进制写方式打开,可以读、写文件, 如果文件不存在,创建该文件.如果文件存在。先清空,再打开文件

    ab

    追读写二进制。从文件顶部读取内容 从文件底部添加内容 不存在则创建

    5.2,关闭文件

    f.close()
    

      当文件读写完毕后,应关闭文件

    六,清空文件内容

    f.truncate()
    

      注意:仅当以 "r "   "rb "    "w"   "wb" "wb "等以可写模式打开的文件才可以执行该功能

    3.5 上下文管理

    with open('a.txt','w') as f:          # 如此方式,当with代码块执行完毕时,内部会自动关闭并释放文件资源。
       pass
    
    with open('a.txt','r') as read_f,open('b.txt','w') as write_f:     #在Python 2.7 后,with又支持同时对多个文件的上下文进行管理,即:
        data=read_f.read()
        write_f.write(data)
    

    六,清空文件内容

    f.truncate()
    

      注意:仅当以 "r "   "rb "    "w"   "wb" "wb "等以可写模式打开的文件才可以执行该功能

    七,文件的指针定位与查询

    7.1,文件指针:
          文件被打开后,其对象保存在 f 中, 它会记住文件的当前位置,以便于执行读、写操作,这个位置称为文件的指针( 一个从文件头部开始计算的字节数 long 类型 )。

    7.2,文件打开时的位置:

          以"r"   "r "   "rb " 读方式, "w"   "w "   "wb "写方式 打开的文件,
         一开始,文件指针均指向文件的头部。

    7.3,获取文件指针的值:

     L = f.tell()
    

      
    7.4,移动文件的指针

     f.seek(   偏移量, 选项 )
    
    
          选项 =0 时, 表示将文件指针指向从文件头部到 "偏移量"字节处。
    
    
          选项 =1 时, 表示将文件指针指向从文件的当前位置,向后移动 "偏移量"字节。
    
    
          选项 =2 时, 表示将文件指针指向从文件的尾部,,向前移动 "偏移量"字节。
    

    3.6 模拟tail -f命令 功能

    import time
    with open('access.log','r',encoding='utf-8') as f:
        f.seek(0,2)          # 打开文件后立刻将光标移动至文件末尾
        while True:
            line=f.readline().strip()
            if line:
                print('新增一行日志',line)
            time.sleep(0.5)           
    

    七,文件的指针定位与查询

    7.1,文件指针:
          文件被打开后,其对象保存在 f 中, 它会记住文件的当前位置,以便于执行读、写操作,这个位置称为文件的指针( 一个从文件头部开始计算的字节数 long 类型 )。

    7.2,文件打开时的位置:

          以"r"   "r "   "rb " 读方式, "w"   "w "   "wb "写方式 打开的文件,
         一开始,文件指针均指向文件的头部。

    7.3,获取文件指针的值:

     L = f.tell()
    

      
    7.4,移动文件的指针

     f.seek(   偏移量, 选项 )
    
    
          选项 =0 时, 表示将文件指针指向从文件头部到 "偏移量"字节处。
    
    
          选项 =1 时, 表示将文件指针指向从文件的当前位置,向后移动 "偏移量"字节。
    
    
          选项 =2 时, 表示将文件指针指向从文件的尾部,,向前移动 "偏移量"字节。
    

    八,从文件读取内容

    8.1,文本文件(以"rt"方式打开的文件)的读取  

    s = f.readline(     )
    
    
            返回值: s 是字符串,从文件中读取的一行,含行结束符。
    
    
            说明: (1)  如果 len( s ) =0 表示已到文件尾
    
    
                        (2)   如果是文件的最后一行,有可能没有行结束符
    

    8.2,二进制文件(以"rb"、"rb "、"wb " 方式打开的文件)的读取  

    s = f.read(    n )
    
    
         说明: (1)  如果 len( s ) =0 表示已到文件尾
    
    
                      (2)   文件读取后,文件的指针向后移动 len(s) 字节。
    
    
                    (3)如果磁道已坏,会发生异常。
    

    3.7  文件的修改

    import os
    with open('a.txt','r',encoding='utf-8') as read_f,
            open('.a.txt.swap','w',encoding='utf-8') as write_f:
        for line in read_f:
            if line.startswith('hello'):
                line='哈哈哈n'
            write_f.write(line)
    
    os.remove('a.txt')
    os.rename('.a.txt.swap','a.txt')
    

    那么问题来了...

    1、如何在线上环境优雅的修改配置文件?

    新葡亰496net 14新葡亰496net 15

    global       
            log 127.0.0.1 local2
            daemon
            maxconn 256
            log 127.0.0.1 local2 info
    defaults
            log global
            mode http
            timeout connect 5000ms
            timeout client 50000ms
            timeout server 50000ms
            option  dontlognull
    
    listen stats :8888
            stats enable
            stats uri       /admin
            stats auth      admin:1234
    
    frontend oldboy.org
            bind 0.0.0.0:80
            option httplog
            option httpclose
            option  forwardfor
            log global
            acl www hdr_reg(host) -i www.oldboy.org
            use_backend www.oldboy.org if www
    
    backend www.oldboy.org
            server 100.1.7.9 100.1.7.9 weight 20 maxconn 3000
    
    原配置文件
    

    原配置文件

    新葡亰496net 16新葡亰496net 17

    1、查
        输入:www.oldboy.org
        获取当前backend下的所有记录
    
    2、新建
        输入:
            arg = {
                'bakend': 'www.oldboy.org',
                'record':{
                    'server': '100.1.7.9',
                    'weight': 20,
                    'maxconn': 30
                }
            }
    
    3、删除
        输入:
            arg = {
                'bakend': 'www.oldboy.org',
                'record':{
                    'server': '100.1.7.9',
                    'weight': 20,
                    'maxconn': 30
                }
            }
    
    需求
    

    需求

    新葡亰496net 18新葡亰496net 19

    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
    import os
    
    def query(content):
        '''
        功能: 根据用户传入的域名查找相关的配置信息,返回一个列表
        :param content: 用户输入的域名
        :return: data
        '''
        res_list = []
        content = 'backend %s' % content
        with open('haproxy.conf', 'r', encoding='utf-8') as fo:
            flag = False
            for line in fo:
                line = line.strip()
                if line.startswith('backend') and content == line:
                    flag = True
                    continue
                if flag:
                    res_list.append(line)
                    flag = False
                    continue
            return res_list
    
    def add(content):
        '''
        功能: 获取用户输入内容并写入文件
        :param content:
        :return:
        '''
        # 用于存放写入文件内容的列表
        data_list = []
        data_dic = eval(content)
        # print('转化为字典: ', data_dic)
        backend = data_dic.get('backend')
        server = data_dic.get('record')
        server_con = "server {} {} weight {} maxconn {}".format(server['server'], server['server'], server['weight'],
                                                                server['maxconn'])
        query_list = query(backend)
        if server_con in query_list:
            print('33[1;31m内容已存在!33[0m')
        else:
            ele = 'backend %s' % backend
            data_list.append(ele)
            data_list.append(server_con)
            with open('haproxy.conf','a ',encoding='utf-8') as fo:
                for item in data_list:
                    if item.strip().startswith('backend'):
                        fo.write('n')
                        fo.write("n%sn" % item)
                    else:
                        fo.write('tt%s' % item)
                print('33[1;32m写入成功!33[0m')
    
    def remove(content):
        """
        功能: 查找到用户输入的内容并删除
        :param content:
        :return:
        """
        data_dic = eval(content)
        backend_con = data_dic.get('backend')
        server_dic = data_dic.get('record')
        data = "server {} {} weight {} maxconn {}".format(server_dic['server'], server_dic['server'],
                                                          server_dic['weight'], server_dic['maxconn'])
        match = "backend %s" % backend_con
        data_list = query(backend_con)
        # print("query: ", data_list)
        if not data_list or data not in data_list:
            print("33[1;31m内容不存在!33[0m")
            return
        elif data in data_list:
            flag = False
            with open('haproxy.conf', encoding='utf-8') as read_f, open('ha.swap', 'w', encoding='utf-8') as write_f:
                for line in read_f:
                    line = line.strip()
                    if line.startswith('backend') and match == line:
                        flag = True
                        continue
                    if flag and data == line:
                        flag = False
                        continue
                    elif flag and data != line:
                        flag = False
                        write_f.write('%sn' % match)
                    if not flag:
                        write_f.write('%sn' % line)
                print('删除成功!')
        os.rename("haproxy.conf","haproxy.conf_bak")
        os.rename("ha.swap","haproxy.conf")
    
    
    if __name__ == '__main__':
        info = """
        1. 查询
        2. 增加
        3. 删除
        4. 退出
        """
        print(info)
        menu_dic = {
            '1': query,
            '2': add,
            '3': remove,
            '4': exit
        }
        while True:
            choice = input("请选择您需要操作的id: ").strip()
            if not choice or choice not in menu_dic: continue
            if choice == '4': break
            content = input("请输入内容: ").strip()
            # content = "{'backend': 'www.oldboy.org','record':{'server': '100.1.7.9','weight': 20,'maxconn': 300}}"
            # content = "www.oldboy.org"
            if choice == '1':
                res_list = menu_dic[choice](content)  # 用choice作为key,从字典中获取到对应的函数对象后加(),即调用函数,将content作为参数传入函数
                if res_list:
                    print("33[1;32m查询的结果为:33[0m %s" % res_list)
                else:
                    print("33[1;31m未查找到内容33[0m")
            else:
                menu_dic[choice](content)
    

    demo

     

    详细参考: 

     

    八,从文件读取内容

    8.1,文本文件(以"rt"方式打开的文件)的读取  

    s = f.readline(     )
    
    
            返回值: s 是字符串,从文件中读取的一行,含行结束符。
    
    
            说明: (1)  如果 len( s ) =0 表示已到文件尾
    
    
                        (2)   如果是文件的最后一行,有可能没有行结束符
    

    8.2,二进制文件(以"rb"、"rb "、"wb " 方式打开的文件)的读取  

    s = f.read(    n )
    
    
         说明: (1)  如果 len( s ) =0 表示已到文件尾
    
    
                      (2)   文件读取后,文件的指针向后移动 len(s) 字节。
    
    
                    (3)如果磁道已坏,会发生异常。
    

    九,向文件写入一个字符串

    f.write(    s )
    
    
        参数:       s 要写入的字符串
    
    
        说明: (1)文件写入后,文件的指针向后移动 len(s) 字节。
    
    
                     (2)如果磁道已坏,或磁盘已满会发生异常。
    
    
    返回值: s 是字符串,从文件中读取的内容
    

    新葡亰496net:文件操作,文件操作总结。九,向文件写入一个字符串

    f.write(    s )
    
    
        参数:       s 要写入的字符串
    
    
        说明: (1)文件写入后,文件的指针向后移动 len(s) 字节。
    
    
                     (2)如果磁道已坏,或磁盘已满会发生异常。
    
    
    返回值: s 是字符串,从文件中读取的内容
    

    十,删除文件

    import os
    
    
    os.remove(file)
    
    import os
    os.remove('s.txt')
    

    十,删除文件

    import os
    
    
    os.remove(file)
    
    import os
    os.remove('s.txt')
    

    3.3 python逐行读取文件内容的两种方法

    方法一:

    for line in open('f.txt'):
        print(line)
    

    方法二:

    f =open('f.txt','r')
    lines =f.readlines()
    for i in lines:
        print(i)
    

    3.3 python逐行读取文件内容的两种方法

    方法一:

    for line in open('f.txt'):
        print(line)
    

    方法二:

    f =open('f.txt','r')
    lines =f.readlines()
    for i in lines:
        print(i)
    

     3.4文件定位

      tell()方法告诉你文件内的当前位置, 换句话说,下一次的读写会发生在文件开头这么多字节之后。

      seek(offset [,from])方法改变当前文件的位置。Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。

      如果from被设为0,这意味着将文件的开头作为移动字节的参考位置。

      如果设为1,则使用当前的位置作为参考位置。

      如果它被设为2,那么该文件的末尾将作为参考位置。

    例子:

    #打开一个文件
    f =open('f.txt','r ')
    str_read = f.read(10)
    print("读取的字符串是:%s" % str_read)
    
    #查找当前位置
    position = f.tell()
    print("当前位置: %s" %position)
    
    #把指针再次重新定位到文件开头
    position =f.seek(0,0)
    str_read =f.read(10)
    print("重新读取读取的字符串是:%s" % str_read)
    
    #关闭文件
    f.close()
    
    结果:
    读取的字符串是:2204513940
    当前位置: 10
    重新读取读取的字符串是:2204513940
    

     3.4文件定位

      tell()方法告诉你文件内的当前位置, 换句话说,下一次的读写会发生在文件开头这么多字节之后。

      seek(offset [,from])方法改变当前文件的位置。Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。

      offset -- 偏移量,也就是代表需要移动偏移的字节数,注意是按照字节算的,字符编码存每个字符所占的字节长度不一样。

        如“好好学习” 用gbk存是2个字节一个字,用utf-8就是3个字节,因此以gbk打开时,seek(4) 就把光标切换到了“飞”和“学”两个字中间。
        但如果是utf8,seek(4)会导致,拿到了飞这个字的一部分字节,打印的话会报错,因为处理剩下的文本时发现用utf8处理不了了,因为编码对不上了。少了一个字节。

      如果from被设为0,这意味着将文件的开头作为移动字节的参考位置。

      如果设为1,则使用当前的位置作为参考位置。

      如果它被设为2,那么该文件的末尾将作为参考位置。

    例子:

    #打开一个文件
    f =open('f.txt','r ')
    str_read = f.read(10)
    print("读取的字符串是:%s" % str_read)
    
    #查找当前位置
    position = f.tell()
    print("当前位置: %s" %position)
    
    #把指针再次重新定位到文件开头
    position =f.seek(0,0)
    str_read =f.read(10)
    print("重新读取读取的字符串是:%s" % str_read)
    
    #关闭文件
    f.close()
    
    结果:
    读取的字符串是:2204513940
    当前位置: 10
    重新读取读取的字符串是:2204513940
    

    3.5 重命名和删除文件

    Python的os模块提供了帮你执行文件处理操作的方法,比如重命名和删除文件。

    要使用这个模块,你必须先导入它,然后才可以调用相关的各种功能。

    rename()方法:

    rename()方法需要两个参数,当前的文件名和新文件名。

    语法:

    os.rename(current_file_name, new_file_name)
    

    例子:

    import os
    #重命名文件f.txt问哦file.txt
    os.rename('f.txt','file.txt')
    

    remove方法

    你可以用remove()方法删除文件,需要提供要删除的文件名作为参数。

    语法:

    os.remove(file_name)
    

    例子:

    import os
    os.remove('stdout.txt')
    

      

     

    3.5 重命名和删除文件

    Python的os模块提供了帮你执行文件处理操作的方法,比如重命名和删除文件。

    要使用这个模块,你必须先导入它,然后才可以调用相关的各种功能。

    rename()方法:

    rename()方法需要两个参数,当前的文件名和新文件名。

    语法:

    os.rename(current_file_name, new_file_name)
    

    例子:

    import os
    #重命名文件f.txt问哦file.txt
    os.rename('f.txt','file.txt')
    

    remove方法

    你可以用remove()方法删除文件,需要提供要删除的文件名作为参数。

    语法:

    os.remove(file_name)
    

    例子:

    import os
    os.remove('stdout.txt')
    

    四,补充内容

    3.6 文件修改

      硬盘的存储原理就是,当你把文件存到硬盘上,就在硬盘上划了一块空间,存数据,等你下次打开这个文件,会seek到一个位置,每改一个字,就是把原来的覆盖掉,如果要插入,是不可能的,因为后面的数据在硬盘上不会整体向后移动,所以就会出现当前这个情况,你要插入,却变成把旧内容覆盖掉。

      所以修改文件,就不要在硬盘上修改,把内容全部读到内存里,数据在内存里可以随便增删改查,修改之后,把内容全部写回硬盘,把原来的数据全部覆盖掉。

      当然了,如果有些文件特别大,比如5G,那么一下吃掉这么大内存,非常浪费资源,所以更好的方法就是,如果不像占内存,那么就边读边写,也就是不修改源文件,但是可以打开丢文件的同时,生成一个新文件,边从旧的里面读,边往新的里面写,遇到需要修改的就改了再写道新文件,这样在内存里面一直只存一行内容,就不占内存了,但是也有一个缺点就是,虽然不占内存,但是占硬盘,每次修改,都要生成一份新文件,虽然改完后,可以把旧的覆盖掉,但是在改的过程中,还是有两份数据

     

      3.6.1文件修改占硬盘

    代码:

    f_name= 'file.txt'
    f_new_name = 'file_new.txt'
    old_str = '123'
    new_str = '123123123'
    
    f = open(f_name,'r',encoding='gbk')
    f_new = open(f_new_name,'w',encoding='gbk')
    
    for line in f:
        if old_str in line:
            line = line.replace(old_str,new_str)
        f_new.write(line)
    f.close()
    f_new.close()
    

      上面的代码会生成一个修改后的新文件,源文件不动,若想覆盖源文件

    代码如下:

     

    import os
    os.replace(file_new_name,file_name)
    

      3.6.2文件修改占内存

      这样不需要占用两个文件,只需要写一个文件,直接r 就可以,但是会出现一个问题,就是要是以前文件内容多,现在少了,那会出错,为了避免这种错误的发生,使用truncate()就ok

     userinfo.txt的内容:

    1:www.baidu.com
    2:www.google.com
    3:www.tencent.com
    4:www.tianmao.com
    5:www.jingdong.com
    

      

    f.truncate([size])
    把文件裁成规定的大小,默认的是裁到当前文件操作标记的位置。
    如果size比文件的大小还要大,依据系统的不同可能是不改变文件,
    也可能是用0把文件补到相应的大小,也可能是以一些随机的内容加上去。
    
    file = open('userinfo.txt','r ',encoding='utf-8')
    print('文件名为:',file.name)
    
    line =file.readline()
    print('读取第一行:%s' %line)
    
    #截断剩下的字符串
    file.truncate()
    
    #尝试再次读取数据
    line =file.readline()
    print('读取数据:%s' %line)
    
    file.close()
    
    # 结果:
    # 文件名为: userinfo.txt
    # 读取第一行:1:www.baidu.com
    # 
    # 读取数据:2:www.google.com
    

      

     

    file = open('userinfo.txt','r ',encoding='utf-8')
    print('文件名为:',file.name)
    
    line =file.readline()
    print('读取第一行:%s' %line)
    
    #截断10的字符串
    file.truncate(10)
    
    #尝试再次读取数据
    line =file.readline()
    print('读取数据:%s' %line)
    
    file.close()
    
    结果:
    文件名为: userinfo.txt
    读取第一行:1:www.baid
    读取数据:
    

      

     

    4.1 各种系统操作

      注意:虽然python中提供了各种拼接目录的函数,但是,函数并不能保证字符编码不出问题,很大可能导致程序错误。所以最好还是自己拼接。

       python中对文件、文件夹(文件操作函数)的操作需要涉及到os模块和shutil模块。

    得到当前工作目录,即当前Python脚本工作的目录路径: os.getcwd()
    
    返回指定目录下的所有文件和目录名:os.listdir()
    
    函数用来删除一个文件:os.remove()
    
    删除多个目录:os.removedirs(r“c:python”)
    
    检验给出的路径是否是一个文件:os.path.isfile()
    
    检验给出的路径是否是一个目录:os.path.isdir()
    
    判断是否是绝对路径:os.path.isabs()
    
    检查是否快捷方式os.path.islink ( filename )
    
    检验给出的路径是否真地存:os.path.exists()
    
    返回一个路径的目录名和文件名:os.path.split() eg os.path.split('/home/swaroop/byte/code/poem.txt') 结果:('/home/swaroop/byte/code', 'poem.txt')
    
    分离扩展名:os.path.splitext()
    
    获取路径名:os.path.dirname()
    
    获取文件名:os.path.basename()
    
    运行shell命令: os.system()
    
    读取和设置环境变量:os.getenv() 与os.putenv()
    
    给出当前平台使用的行终止符:os.linesep Windows使用'rn',Linux使用'n'而Mac使用'r'
    指示你正在使用的平台:os.name 对于Windows,它是'nt',而对于Linux/Unix用户,它是'posix'
    重命名:os.rename(old, new)
    
    创建多级目录:os.makedirs(r“c:pythontest”)
    
    创建单个目录:os.mkdir(“test”)
    
    获取文件属性:os.stat(file)
    
    修改文件权限与时间戳:os.chmod(file)
    
    终止当前进程:os.exit()
    
    获取文件大小:os.path.getsize(filename)
    

      

    四,补充内容

    4.2 各种目录操作

    os.mkdir("file") 创建目录
    
    复制文件:
    shutil.copyfile("oldfile","newfile") oldfile和newfile都只能是文件
    shutil.copy("oldfile","newfile") oldfile只能是文件夹,newfile可以是文件,也可以是目标目录
    
    复制文件夹:
    shutil.copytree("olddir","newdir") olddir和newdir都只能是目录,且newdir必须不存在
    
    重命名文件(目录)
    os.rename("oldname","newname") 文件或目录都是使用这条命令
    
    移动文件(目录)
    shutil.move("oldpos","newpos") 
    
    删除文件
    os.remove("file")
    
    删除目录
    os.rmdir("dir")只能删除空目录
    shutil.rmtree("dir") 空目录、有内容的目录都可以删
    
    转换目录
    os.chdir("path") 换路径
     
    ps: 文件操作时,常常配合正则表达式:
    img_dir = img_dir.replace('\','/')
    

     

    文件操作总结,python文件操作总结 文件操作对于编程语言的重要性不言而喻,如果数据不能持久保存,信息技术也就失去了意义。 文...

    4.1 各种系统操作

      注意:虽然python中提供了各种拼接目录的函数,但是,函数并不能保证字符编码不出问题,很大可能导致程序错误。所以最好还是自己拼接。

       python中对文件、文件夹(文件操作函数)的操作需要涉及到os模块和shutil模块。

    得到当前工作目录,即当前Python脚本工作的目录路径: os.getcwd()
    
    返回指定目录下的所有文件和目录名:os.listdir()
    
    函数用来删除一个文件:os.remove()
    
    删除多个目录:os.removedirs(r“c:python”)
    
    检验给出的路径是否是一个文件:os.path.isfile()
    
    检验给出的路径是否是一个目录:os.path.isdir()
    
    判断是否是绝对路径:os.path.isabs()
    
    检查是否快捷方式os.path.islink ( filename )
    
    检验给出的路径是否真地存:os.path.exists()
    
    返回一个路径的目录名和文件名:os.path.split() eg os.path.split('/home/swaroop/byte/code/poem.txt') 结果:('/home/swaroop/byte/code', 'poem.txt')
    
    分离扩展名:os.path.splitext()
    
    获取路径名:os.path.dirname()
    
    获取文件名:os.path.basename()
    
    运行shell命令: os.system()
    
    读取和设置环境变量:os.getenv() 与os.putenv()
    
    给出当前平台使用的行终止符:os.linesep Windows使用'rn',Linux使用'n'而Mac使用'r'
    指示你正在使用的平台:os.name 对于Windows,它是'nt',而对于Linux/Unix用户,它是'posix'
    重命名:os.rename(old, new)
    
    创建多级目录:os.makedirs(r“c:pythontest”)
    
    创建单个目录:os.mkdir(“test”)
    
    获取文件属性:os.stat(file)
    
    修改文件权限与时间戳:os.chmod(file)
    
    终止当前进程:os.exit()
    
    获取文件大小:os.path.getsize(filename)
    

      

    4.2 各种目录操作

    os.mkdir("file") 创建目录
    
    复制文件:
    shutil.copyfile("oldfile","newfile") oldfile和newfile都只能是文件
    shutil.copy("oldfile","newfile") oldfile只能是文件夹,newfile可以是文件,也可以是目标目录
    
    复制文件夹:
    shutil.copytree("olddir","newdir") olddir和newdir都只能是目录,且newdir必须不存在
    
    重命名文件(目录)
    os.rename("oldname","newname") 文件或目录都是使用这条命令
    
    移动文件(目录)
    shutil.move("oldpos","newpos") 
    
    删除文件
    os.remove("file")
    
    删除目录
    os.rmdir("dir")只能删除空目录
    shutil.rmtree("dir") 空目录、有内容的目录都可以删
    
    转换目录
    os.chdir("path") 换路径
     
    ps: 文件操作时,常常配合正则表达式:
    img_dir = img_dir.replace('\','/')
    

     

    五,文件处理习题

      文件操作分为读,写,修改

    5.1 读文件

    举例如下:

    f = open(file=‘userinfo.txt',mode='r',encoding='utf-8')
    
    data = f.read()
    
    f.close()
    

    上述操作语法解释如下:

    file=‘userinfo.txt'  表示文件路径
    mode='r'                                          表示只读(可以修改为其他)
    encoding='utf-8'                                  表示将硬盘上的 0101010 按照utf-8的规则去“断句”,
        再将“断句”后的每一段0101010转换成unicode的 01010101,unicode对照表中有01010101和
        字符的对应关系。
    f.read()                                          表示读取所有内容,内容是已经转换完毕的字符串。
    f.close()                                         表示关闭文件
    

      再看一个例子:

    f = open(file='userinfo.txt',mode='rb')
    data = f.read()
    f.close()
    

    上述操作语法解释:

    file='userinfo.txt'      表示文件路径
    mode='rb'                                            表示只读(可以修改为其他)
    f.read()                                             表示读取所有内容,内容是硬盘上原来以某种编码保存010101010,即:某种编码格式的字节类型
    f.close()                                            表示关闭文件
    

      问:两个例子的区别在哪?

      答:在于示例2打开文件时并未指定encoding,这是为何?是因为直接以rb模式打开了文件 ,rb是指二进制模式,数据读到内存里直接是bytes格式,如果想内容,还需要手动decode,因此在文件打开阶段,不需要指定编码

      问:假设你不知道你要处理的文件是什么编码可怎么办?

    import chardet
    
    f = open('log',mode='rb')
    data = f.read()
    f.close()
    
    result = chardet.detect(open('log',mode='rb').read())
    print(result)
    

      输出:

    {'encoding': 'GB2312', 'confidence': 0.99, 'language': 'Chinese'}
    

      

    注意:

    文件操作时,以 “r”或“rb” 模式打开,则只能读,无法写入;

    硬盘上保存的文件都是某种编码的0101010,打开时需要注意:

    • rb,直接读取文件保存时原生的0101010,在Python中用字节类型表示
    • r和encoding,读取硬盘的0101010,并按照encoding指定的编码格式进行断句,再将“断句”后的每一段0101010转换成unicode的 010101010101,在Python中用字符串类型表示

     5.2文件操作的其他功能

     def fileno(self, *args, **kwargs): # real signature unknown
            返回文件句柄在内核中的索引值,以后做IO多路复用时可以用到
    
        def flush(self, *args, **kwargs): # real signature unknown
            把文件从内存buffer里强制刷新到硬盘
    
        def readable(self, *args, **kwargs): # real signature unknown
            判断是否可读
    
        def readline(self, *args, **kwargs): # real signature unknown
            只读一行,遇到r or n为止
    
        def seek(self, *args, **kwargs): # real signature unknown
            把操作文件的光标移到指定位置
            *注意seek的长度是按字节算的, 字符编码存每个字符所占的字节长度不一样。
            如“路飞学城” 用gbk存是2个字节一个字,用utf-8就是3个字节,因此以gbk打开时,seek(4) 就把光标切换到了“飞”和“学”两个字中间。
            但如果是utf8,seek(4)会导致,拿到了飞这个字的一部分字节,打印的话会报错,因为处理剩下的文本时发现用utf8处理不了了,因为编码对不上了。少了一个字节
    
        def seekable(self, *args, **kwargs): # real signature unknown
            判断文件是否可进行seek操作
    
        def tell(self, *args, **kwargs): # real signature unknown
            返回当前文件操作光标位置 
    
        def truncate(self, *args, **kwargs): # real signature unknown
            按指定长度截断文件
            *指定长度的话,就从文件开头开始截断指定长度,不指定长度的话,就从当前位置到文件尾部的内容全去掉。
    
        def writable(self, *args, **kwargs): # real signature unknown
            判断文件是否可写
    

      

    5.3 例题

    读文件找到第9个字符,华 ,找到第二行的 实,删除最后一行 写入文件
    桃之夭夭,灼灼其华。之子于归,宜其室家。
    桃之夭夭,有蕡其实。之子于归,宜其家室。
    桃之夭夭,其叶蓁蓁。之子于归,宜其家人。

    # 2.读文件找到第9个字符,华 ,找到第二行的 实,删除最后一行 写入文件
    # 桃之夭夭,灼灼其华。之子于归,宜其室家。
    # 桃之夭夭,有蕡其实。之子于归,宜其家室。
    # 桃之夭夭,其叶蓁蓁。之子于归,宜其家人。
    
    f = open('poem.txt', 'r ', encoding='utf-8')
    # f.seek(3*8)
    # print(f.read(1))
    # f.seek(3*28 2)
    # print(f.read(1))
    data_list = f.readlines()
    print(data_list)
    data_list.pop()
    print(data_list)
    f.seek(0)
    f.truncate()
    f.write(''.join(data_list))
    

      

    本文由新葡亰496net发布于奥门新萄京娱乐场,转载请注明出处:新葡亰496net:文件操作,文件操作总结

    关键词:

上一篇:新葡亰496net:2上编译安装Swift,详细图文

下一篇:没有了