澳门新萄京官方网站-www.8455.com-澳门新萄京赌场网址

澳门新萄京官方网站:python全栈开荒,文件操作

2019-07-27 作者:www.8455.com   |   浏览(162)

  文件操作对于编制程序语言的重要分明,假若数额不可能长久保存,音讯手艺也就错失了意思。

python 文件操作总计,python文件操作总计

  文件操作对于编制程序语言的主要总之,要是数量不可能始终如一保存,消息技术也就错失了意义。

  文件操作的剧情满含打开文件,操作文件,关闭文件

一、文件操作步骤

  1. 开辟文件,获得文件句柄并赋值给五个变量
  2. 由此句柄对文件举办操作
  3. 关门文件

澳门新萄京官方网站 1澳门新萄京官方网站 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的作⽤:

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

艺术直接显⽰出来的. 在后⾯我们⽂件上传下载的时候还会⽤到. 还会有. 大家看的直播. 实际上都以那

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

夹下的⽂件. 相对于目前以此顺序所在的⽂件夹⽽⾔. 借使在同 ⼀个⽂件夹中. 则相对路线就是其一⽂

件名. 倘若在上⼀层⽂件夹. 则要../

澳门新萄京官方网站 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-拾贰个字节的开始和结果,文件必须以写方式张开,可是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)

奉行结果:

澳门新萄京官方网站 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)
#结果:
友谊地
久天⻓

追Gavin件示例

方法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。

内容为:

澳门新萄京官方网站 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)

实行结果:

澳门新萄京官方网站 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())

施行结果:

澳门新萄京官方网站 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了须臾间,才会保留到硬盘中去。

#刚写完一行内容,如果决电,他就没有写进去,断电内部存款和储蓄器中数据就能遗弃。若无断电,数据还在内部存款和储蓄器的缓存中,需求刷新一下,手艺写到硬盘中。

#内全数四个尺寸限制,须求到达那些尺寸,才会把内部存款和储蓄器缓存中的内容写到硬盘中。

澳门新萄京官方网站 8

澳门新萄京官方网站 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)   向文件写入一个序列字符串列表,如果需要换行则要自己加入每行的换行符。

 

 

 

 

 

 

 

 

 

 

 

 

澳门新萄京官方网站:python全栈开荒,文件操作总计。 

 

 

 

 

 

 

 

 

四. 追加(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文件中的内容

澳门新萄京官方网站 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(内部存款和储蓄器速度快于硬盘,假设写入文件的数码都从内部存款和储蓄器刷到硬盘,内部存储器与硬盘的速度延迟会被Infiniti放大,作用变低,所以要刷到硬盘的数量大家归总往内部存款和储蓄器的一小块空间即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文件内容

澳门新萄京官方网站 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)

实行结果:

澳门新萄京官方网站 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)

进行结果:

澳门新萄京官方网站 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的十个随机整数

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的随意整数, 13个数字一行,共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的轻便整数, 12个数字一行,共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、如何在线上意况幽雅的修改配置文件?

澳门新萄京官方网站 14澳门新萄京官方网站 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

原配置文件

原配置文件

澳门新萄京官方网站 16澳门新萄京官方网站 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
            }
        }

需求

需求

澳门新萄京官方网站 18澳门新萄京官方网站 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 是字符串,从文件中读取的内容

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

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

  

本文由澳门新萄京官方网站发布于www.8455.com,转载请注明出处:澳门新萄京官方网站:python全栈开荒,文件操作

关键词: