因为懂你,文件对象

目录:

一、文件对象

文本对象是Python代码访问、操作磁盘上文件的根本接口。文件对象不仅能够用来走访普通的磁盘文件,而且也能够访问任何别的项目抽象层面上的
“文件”。①旦设置了合适的”钩子”,你就可以访问具备文件类型接口的别样对象,就像访问的是常见文书1律。实行这种肤浅管理的主要缘由是多多益善的输入/输出数据结构更趋向于使用通用的接口。那样就可以在先后作为和兑现上维持一致性。

文本只是连连的字节种类(字符串),数据的传导通常会用到字节流,无论字节流是由单个字节仍旧大块数据整合。对Python来说,文件的剧情总是字符串,无故事集件包蕴的数目是怎么着品种。

前言

前方几节干燥的模块终于甘休了,想要完全调整前几节的模块供给不停的勤学苦练才行,究竟眼过千遍不如手过贰回嘛。在有的门类需要里,要对文本进行IO操作,终究重要数据不容许打字与印刷到显示屏上而不去保存,Python对的公文IO操作并不是很复杂,相信你快捷就能调控它!

Lesson_7


  1、展开文件

二、内建函数 open()

从没特定的常量语法(也正是想创设列表那样采纳标记表明式
[ ])制造文件对象。要开创2个文件对象,需求调用内建函数 open()
,内建函数 open() 提供了起头化输入/输出(I/O)操作的通用接口。 open()
内建函数成功打开文件后时候会再次来到二个文本对象,对该文件实行后继相关的操作都要用到这么些目标,打开不成功会掀起2个
IOError
格外。成功再次来到的文本对象足以看成计算机上的一个文件链接,你可以通过调用重临的文件对象的不贰诀要来读写相关外部文件。

文件IO操作

对此七个文书的操作,无非不过创造、删除、读、写,成立和删除在OS模块里面早已说过,那只剩余读和写了,也正是IO(Input,Output)操作了。

接下去,将以徐章垿的《再别康桥》为例子,深刻解读Python中文件IO操作

轻轻的我走了,正如我轻轻的来;我轻轻的招手,作别西天的云彩。----那河畔的金柳,是夕阳中的新娘;波光里的艳影,在我的心头荡漾。----软泥上的青荇,油油的在水底招摇;在康河的柔波里,我甘心做一条水草!----那榆荫下的一潭,不是清泉,是天上虹;揉碎在浮藻间,沉淀着彩虹似的梦。----寻梦?撑一支长篙,向青草更青处漫溯⑷;满载一船星辉,在星辉斑斓里放歌。----但我不能放歌,悄悄是别离的笙箫;夏虫也为我沉默,沉默是今晚的康桥!----悄悄的我走了,正如我悄悄的来;我挥一挥衣袖,不带走一片云彩。

【三】装饰器和生成器

  2、文件对象的点子

内建函数 open() 的为主语法是:

file = open( file, mode=’r’, buffering=-1, encoding=None,
errors=None, newline=None, closefd=True, opener=None )

file
是富含要开荒的公文名字的字符串,它能够是绝对路线或然相对路线。未有目录路线时,文件假定期存款在于当下的干活目录中(也正是本子运营的地方)。

可选变量 mode 也是四个字符串,代表文件展开的情势,默以为
'r'。平常,文件使用情势 'r''w',或是 'a'
形式来开发,分别表示读取,写入和充实。还有个 'U'
形式,代表通用换行符支持。在情势字符串尾巴部分加上 'b'
,能够张开2进制数据管理。加上 '+' 意味着同时以读写格局展开文件。

采纳 ‘r’ 或 ‘U’ 情势展开的公文必须是曾经存在的。使用 ‘w’
形式打开的文件若存在则第二清空,然后(重新)创造。以 ‘a’
形式展开的文本是为扩张数据作希图的,全数写入的数量都将大增到文件的最终,尽管你
seek 到了别的的地点。要是文件不设有,将被电动创设,类似以 ‘w’
格局打开文件。

澳门葡京备用网址 ,除此以外1个可选参数 buffering 用于提醒访问文件所利用的缓冲格局。在那之中
0 表示不缓冲,1 表示只缓冲壹行数据,任何其余大于 壹的值代表行使给定值作为缓冲区大小。不提供该参数或然给定负值代表采用系统暗中认可缓冲机制,既对其余类电报机(
tty
)设备选择行缓冲,其它设备选取正规缓冲。一般景观下使用系统暗中认可格局就能够。

encoding 参数能够钦点大家开拓文件所运用的编码格局,举个例子 utf-8
或者
gbk。请保管使用文件本人的编码方式张开,不然会冒出乱码,2进制文件默许生成
bytes 字符串类型,不能够钦命 encoding 参数。

借使您不领会文书的编码,能够行使第一方的 chardet 模块的
detect() 函数来赞助估摸文件的编码格式。使用detect()
函数,你必要首先选择‘rb’情势也正是以2进制模型张开文件,然后文件中读取的bytes格式的字符串传递给detect()函数,detect()
函数会将猜想的结果作为函数的结果回到。

澳门葡京备用网址 1

回到的 confidence
提出了判定的确切程度,encoding指出了这几个函数判定的文件的编码格式。

一. 张开文件

Python获得文件句柄的不2秘籍与c及其类似,使用内置函数open(file, mode=’r’,
buffering=-1, encoding=None, errors=None, newline=None, closefd=True,
opener=None)
「file表示文件名、mode表示张开药格局、buffering表示寄存区缓冲大小(负值为系统默许,0为未有寄存区缓存,一为文件会寄存行,大于一的整数为寄存区缓存大小)、encoding表示文件编码、newline表示换行符」

f = open('再别康桥.txt')   # 以默认读的方式打开再别康桥,注意:文件路径(此时程序和再别康桥在同一路径)f = open('xxx.txt', 'w')   # 以写的方式打开文件,注意:如果此文件不存在,则创建这个文件;如果存在,则删除原文件所有内容

对此区别的文书,有例外的管理格局,常用的mode参数如下:

模式                                                描述 r                                                  读 w                                                  写 r+                                                读写 w+                                                写读 a                                                 追加 a+                                               追加读 rb                                              二进制读 wb                                              二进制写 rb+                                            二进制读写 wb+                                            二进制写读 ab                                             二进制追加 ab+                                           二进制追加读

这一个方式类似复杂,其实里面规律很清楚,接下去将用文件的读和写来丰硕领悟那么些方式

生成器

咱俩知道通过列表生成式,大家能够直接创建列表。不过了会遭到内部存款和储蓄器的限制,列表体量肯定是受限制的。而且,制造多个暗含十0元个要素的列表,不仅占用内部存款和储蓄器空间,倘若我们无非须求拜访前边几个因素,那背后绝诸多素成分占用的半空中白白浪费了。

之所以,即使列表成分得以根据某种算法推算出来的话,那大家是或不是足以在循环的经过中持续推算出后续的因素呢?那样就不要创设完整的list,从而省去多量的半空中。在python中,那壹种1边循环一边企图的的体制,称为生成器(generator)。

第2类:生成器函数:依然采用 def
定义函数,可是,使用yield而不是return语句再次来到结果。yield语句一遍回到3个结实,在每一种结果中间,挂起函数的气象,以便下次从它离开的地点继续推行。

如下案例加以证实:

# 使用next()生成斐波那契数列
def Fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n += 1
    return '亲!没有数据了...'
# 调用方法,生成出10个数来
f=Fib(10)



# 使用一个循环捕获最后return 返回的值,保存在异常StopIteration的value中
list1 = []
while  True:
    try:
        x = next(f)
        list1.append(x)
    except StopIteration as e:
        print("生成器最后的返回值是:",e.value)
        break
print(list1)

其次类:生成器表达式:类似于列表推导,只可是是把一对大括号[]改换为1对小括号()。不过,生成器表明式是按需发生2个生成器结果对象,要想获得每三个因素,就须求循环遍历。

正如案例加以证实:

generator1 = [ i*i for i in range(10)]
generator2 = ( i*i for i in range(10))
print(generator1)
print(generator2)

for i in generator2:
    print(i)

#[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
#<generator object <genexpr> at 0x10452a0a0>

  三、文件的闭馆

文件对象的走访情势

文件模式 操作
r 以只读方式打开
rU 或 Ua 以读方式打开, 同时提供通用换行符支持 (PEP 278)
w 以写方式打开 ,如果文件存在就先清空文件,如果不存在就创建新文件
a 以追加模式打开 (从 EOF 开始, 必要时创建新文件)
+ 以读写模式打开
w+ 以读写模式打开 (参见 w )
a+ 以读写模式打开 (参见 a )
rb 以二进制读模式打开
wb 以二进制写模式打开 (参见 w )
ab 以二进制追加模式打开 (参见 a )
rb+ 以二进制读写模式打开 (参见 r+ )
wb+ 以二进制读写模式打开 (参见 w+ )
ab+ 以二进制读写模式打开 (参见 a+ )
x 文件存在报错,不存在就创建写内容

贰. 文本的读

read() 「读取文件指针之后的富有剧情,并回到字符串」

此处提到了四个新定义:文件指针,想象一下,你在阅读,你的手指指着你正在读的地点,你没读四个字,你的指头就跟着向后动一下,你的指尖正是文本指针,以上形式中,除了a、a+、ab+文件指针在文件末尾之外,别的的都是在文书开端

In [2]: f = open('再别康桥.txt')   # 默认读的方式打开文件In [3]: f.read()                  # 读取文件指针之后的所有内容Out[3]: '轻轻的我走了,\n正如我轻轻的来;\n我轻轻的招手,\n作别西天的云彩。\n----\n那河畔的金柳,\n是夕阳中的新娘;\n波光里的艳影,\n在我的心头荡漾。\n----\n软泥上的青荇,\n油油的在水底招摇;\n在康河的柔波里,\n我甘心做一条水草!\n----\n那榆荫下的一潭,\n不是清泉,是天上虹;\n揉碎在浮藻间,\n沉淀着彩虹似的梦。\n----\n寻梦?撑一支长篙,\n向青草更青处漫溯;\n满载一船星辉,\n在星辉斑斓里放歌。\n----\n但我不能放歌,\n悄悄是别离的笙箫;\n夏虫也为我沉默,\n沉默是今晚的康桥!\n----\n悄悄的我走了,\n正如我悄悄的来;\n我挥一挥衣袖,\n不带走一片云彩。\n'

In [9]: f = open('再别康桥.txt', 'w')   # 以写的模式打开文件,此时这个文件的内容已经被删除了😰In [10]: f.read()                      # 可以看到文件是不允许读的---------------------------------------------------------------------------UnsupportedOperation                      Traceback (most recent call last)<ipython-input-10-571e9fb02258> in <module>----> 1 f.read()UnsupportedOperation: not readable

In [1]: f = open('test.jpg', 'rb')   # 以二进制方式打开文件In [2]: f.read()Out[2]: b'\xff\xd8\xff\xe0\x00\x10JFIF\x00\x01\x01\x01\x00H\x00H\x00\x00\xff\xdb\x00C\x00\x05\x04\x04\x05\x04\x03\x05\x05\x04\x05\x06\x06\...........'# 有许多文件格式是以二进制保存的,最典型的就是图片和视频

readline() 「读一行」

In [1]: f = open('再别康桥.txt')In [2]: f.readline()   # 读一行Out[2]: '轻轻的我走了,\n'In [3]: f.readline()   # 再读一行Out[3]: '正如我轻轻的来;\n'In [4]: f.readline()Out[4]: '我轻轻的招手,\n'In [5]: f.readline()Out[5]: '作别西天的云彩。\n'

readlines() 「按行读取文件,将有所的行保存为叁个列表」

In [6]: f = open('再别康桥.txt')In [7]: f.readlines()Out[7]:['轻轻的我走了,\n', '正如我轻轻的来;\n', '我轻轻的招手,\n', '作别西天的云彩。\n', '----\n', '那河畔的金柳,\n', '是夕阳中的新娘;\n', '波光里的艳影,\n', '在我的心头荡漾。\n', '----\n', '软泥上的青荇,\n', '油油的在水底招摇;\n', '在康河的柔波里,\n', '我甘心做一条水草!\n', '----\n', '那榆荫下的一潭,\n', '不是清泉,是天上虹;\n', '揉碎在浮藻间,\n', '沉淀着彩虹似的梦。\n', '----\n', '寻梦?撑一支长篙,\n', '向青草更青处漫溯⑷;\n', '满载一船星辉,\n', '在星辉斑斓里放歌。\n', '----\n', '但我不能放歌,\n', '悄悄是别离的笙箫;\n', '夏虫也为我沉默,\n', '沉默是今晚的康桥!\n', '----\n', '悄悄的我走了,\n', '正如我悄悄的来;\n', '我挥一挥衣袖,\n', '不带走一片云彩。\n']

文本迭代 「open函数张开1个文本后,这几个句柄本身是可迭代对象」

In [8]: f = open('再别康桥.txt')In [9]: for line in f:   # 直接迭代文件   ...:     print   ...:轻轻的我走了,正如我轻轻的来;我轻轻的招手,作别西天的云彩。----那河畔的金柳,(将后面的输出省略了)

装饰器

内衣能够遮羞,不过到了冰冷的时令它不可能抵御严寒,于是聪明的人类发明了棉衣棉裤,给我们提供了保暖的功用,装饰器如同棉衣棉裤一样,在不影响内衣的功力下,还能给我们提供另一种功效.

概念:是二个闭包,把三个函数当做参数,重临二个代替版的函数,本质上就是二个重临函数的函数

简易的装饰器

#简单的装饰器
def func1():
    print("上海好啊!!!")

def outer(func):
    def inner():
        print("*******************")
        func()
    return inner
#f是函数func1的加强版本
f = outer(func1)()

复杂一点的装饰器

def outer(func):
    def inner(age):
        if age < 0:
            age = 0
        func(age)
    return inner

#使用@符号将装饰器应用到函数
#@python2.4支持使用@符号
@outer   #相当于say = outer(say)
def say(age):
    print("he is %d years old" % (age))


say(-10)

通用一点的装饰器

def outer(func):
    def inner(*args, **kwargs):
        #添加修改的功能
        print("&&&&&&&&&&&&&")
        return func(*args, **kwargs)
    return inner



@outer #say = outer(say)
def say(name, age): #函数的参数力理论上是无限制的,但实际上最好不要超过6、7个
    print("my name is %s, I am %d years old" % (name, age))
    return "aaaa"


say("tom", 18)

  四、文件的读取和固化

此处是局地开荒文件的例子:

fp = open(‘/etc/motd’) #因为懂你,文件对象。 以读方式张开
fp = open(‘test’, ‘w’) # 以写格局张开
fp = open(‘data’, ‘r+’) # 以读写格局展开
fp = open(r’c:\io.sys’, ‘rb’) # 以2进制读方式展开

澳门葡京备用网址 2

在其余情形下,Python程序中拍卖的文本格式文件都施用字符串的花样。读取文件时会重返字符串格局的文书,文本作为字符串传递给
write()
方法。Python不会百尺竿头更进一步把目的转换为字符串——你不能够不传递叁个业已格式化的字符串。

3. 文本的写

write 「text表示要写入文件的剧情,并回到写入的字符数」

In [13]: f = open('new_file.txt', 'w')   # 以写的方式打开文件,如果文件不存在则创建,如果存在则删除原有内容In [14]: f.write('hello')   # 写入helloOut[14]: 5In [15]: f.write('word\n')   # 写入word并换行Out[15]: 5

小心:假设此刻去查看文件内容,开掘其间恐怕冷静的,为啥吗?因为寄存区缓存的缘故,暗中同意是使用系统的寄存区缓存机制,想要马上写入文件能够更动buffering的值,也足以接纳close()方法关闭文件(关闭文件时具备故事情节都会写入文件)、再或许选用flush()方法立时将寄存区内容写入文件

In [23]: f.flush()   # 使用flush()方法立即刷入In [24]: ! cat new_file.txt   # 使用命令查看文件内容,文件内容有两行,一行字,一行空白(因为使用\n换行了),这个是Linux系统命令🤥helloword

In [25]: f = open('new_file.txt', 'a')   # 以追加模式打开,如果文件存在则打开文件,如果不存在则新建文件In [27]: f.write('i am new\n')Out[27]: 9In [28]: f.flush()In [30]: ! cat new_file.txthellowordi am new

In [31]: f = open('new_file.txt', 'a')In [32]: f.read()   # 追加方式是不允许读的,w、wb、ab也不允许读---------------------------------------------------------------------------UnsupportedOperation                      Traceback (most recent call last)<ipython-input-32-571e9fb02258> in <module>----> 1 f.read()UnsupportedOperation: not readable

In [33]: f = open('new_file.txt', 'a+')   # 使用追加读的方式打开文件In [34]: f.read()    # 可以读,但为什么是空的?因为文件指针在末尾Out[34]: ''In [36]: f.write('afd')   # 也可以写Out[36]: 3

writelines 「将三个列表或元组类别写入文件,必要换行自个儿加」

In [39]: f = open('new_file.txt', 'w')In [43]: f.writelines(['hello','world'])   # 将列表序列写入文件In [44]: f.writelines(('haha','hehe'))     # 将元组序列写入文件In [45]: f.flush()   # 刷入In [46]: ! cat new_file.txt   # 查看文件内容helloworldhahahehe

偏函数

functools,用于高阶函数:指那多少个功效于函数只怕重返别的函数的函数,经常要是是能够被看作函数调用的对象正是其壹模块的目的。

在Python 二.7 中享有如下方法,

cmp_to_key,将一个比较函数转换关键字函数;

partial,针对函数起作用,并且是部分的;

reduce,与python内置的reduce函数功能一样;

total_ordering,在类装饰器中按照缺失顺序,填充方法;

update_wrapper,更新一个包裹(wrapper)函数,使其看起来更像被包裹(wrapped)的函数;

wraps,可用作一个装饰器,简化调用update_wrapper的过程;

偏函数的贯彻:

import functools

print(int("1010", base = 2)) #设置成2进制

def int2(str, base = 2):
    return int(str, base)
print(int2("1011"))


#partial把一个参数固定住,形成一个新的函数
int3 = functools.partial(int, base = 2)
print(int3("111"))

#那么现在int3默认就是返回2进制的

  五、文件的写入

文本文件和二进制文件

在Python 三汉语件类型都由 open() 函数的第贰个参数决定,形式字符串包含多少个’b’
表示以2进制格式张开。Python总是支持文件文件和二进制文件。文本文件把内容表示为常规的
str 字符串,自动试行 Unicode
编码和平解决码,并且暗许试行末行转换。贰进制文件把内容表示为二个非同小可的 bytes
字符串类型,并且同意程序不修改的拜访文件内容。

一般性,你必须采用 bytes 字符串管理2进制文件,使用正规的 str
字符串管理公事文件。其它,由于文本文件贯彻了Unicode编码,无法以文件格局张开三个贰进制数据文件,那样会将其内容解码为Unicode文本,生成乱码,导致败北。其它二进制形式不会对数据实践此外末行转变,他间接读取硬盘汉语件保存的二进制(0十一)并以十陆进制的格式展现。

4. 停息文件

close() 「关闭文件,若是将寄存区有缓存则写入文件」

In [48]: f.close()

第七一章


  陆、课时2八课后习题及答案

通用换行符帮助(UNS)

不等平台用来代表行终止的号子是例外的,例如 \n,\r,或者
\r\n。所以,Python
的解释器也要管理这样的任务,尤其是在导入模块时10分主要。

那就是 UNS 的关键所在,作为 PEP 278 的结果,Python 二.三 引入了
UNS。当您使用 ‘U’
标识展开文件的时候,全数的行分割符(或行甘休符,无论它原先是怎样)通过
Python 的输入方法(举个例子 read*() )重返时都会被轮换为换行符
NEWLINE(\n)。(‘rU’ 形式也支撑 ‘rb’ 选项)
。这些特点还帮忙包括分化门类行结束符的公文。文件对象的 newlines
属性会记录它曾“看到的”文件的行结束符。

若是文件刚被张开,程序还未有遇上行结束符,那么文件的 newlines 为
None。在率先行被读取后,它棉被服装置为率先行的截至符。固然遇上别的品类的行结束符,文件的
newlines 会成为一个富含每一个格式的元组。注意 UNS
只用于读取文本文件。未有对号入座的管理公事输出的措施。在编写翻译 Python
的时候,UNS 私下认可是开拓的。假使您不需求以此性情,在运作 configure
脚本时,你能够使用 –without-universal-newlines
按键关闭它。借使您非要自个儿管理行停止符,使用 os 模块的连带属性。

5. 文本别的措施

tell() 「重临当前文件指针地方」

seek(offset, whence=0) 「offset代表要设置的公文指针地点」

name 「返回当前文件名」

【一】你不容许一而再对的

咱俩是人,不是神,所以咱们日常会犯错,固然你是个经验丰裕的程序猿,也不可能担保你写的代码百分百的尚未难点。

此外作为3个过关的程序猿,再编程的时候你要铭记一点,即是世代都无须相信你的用户。要把她们想象成熊孩子,把她们想象成黑客,这样你才能写出安全平稳的顺序。

大家看例子:

var = float(input('请输入一个数字:'))
print(var)

#请输入一个数字:q
#ValueError: could not convert string to float: 'q'

地点这么些事例就报错了ValueError卓殊,那么python会抛出那多少个可怜了

<image src=’images/错误代码1.png’ width=’500′ >
<image src=’images/错误代码二.png’ width=’500′ >
<image src=’images/错误代码三.png’ width=’500′ >

 

采取 with open 展开文件,代码块实践完,文件都自动关闭

澳门葡京备用网址 3

1、AssertionError:断言语句(assert)战败

assert 关键字 在眼下的章节里面讲过了,在测试程序的时候使用

它在规则不创立的场地下抛出 AssertionError

var = float(input('请输入一个数字'))
assert var<0
print(var)

#请输入一个数字100
#AssertionError

绝大多数先后都坚守着:输入->管理->输出的模型,首先接受输入数据,然后遵照必要开始展览管理,最终输出结果。今后大家不再只满意使用input接受用户的输入,使用print输出管理的结果了。大家热切想要关怀到系统的整个,用代码自动分析类别的日记,分析的结果能够保存为一个新的日记,乃至足以跟外界的社会风气实行调换。

3、文件对象的内建办法

open()
成功实行并赶回三个文本对象之后,全体对该公文的三番5遍操作都将透过那几个”句柄”(文件对象)进行。文件方式能够分成4类:输入,输出,文件内活动,以及杂项操作。

2、AttributeError:尝试访问地方的对象属性

当试图访问的对象属性不设有时抛出万分:

list1 = []
list1.shanghai

#AttributeError: 'list' object has no attribute 'china'

在编写程序的时候,操作系统为了越来越快的做出响应,把装有当前的数据都放在内部存款和储蓄器中。但内部存款和储蓄器有个自然的供不应求,一断点就没戏,emmmm。ctrl

1、输入

read(self, n: int = -1) -> AnyStr
readline(self, limit: int = -1) -> AnyStr
readlines(self, hint: int = -1) -> List[AnyStr]

read()
方法用来一贯读取文件对象并重回字符串,最多读取给定数据个字符(注意不是字节)。借使未有给定
n 参数(默许值为 -一)或然 n 值为负,文件将被读取直至最终。

readline()
方法读取展开文件的一行(读取下个行终止符以前的保有字节)。然后整行(包含行终止符)作为字符串再次来到。和
read() 同样,它也有3个可选的 limit 参数,默以为-一,代表读至行截至符。假设提供了该参数,那么在抢先 limit
个字节后会回来不完全的行。

readlines()
方法并不像别的八个输入方法同样再次来到1个字符串。它会读取全体(剩余的)行然后把它们当做1个字符串列表重临。它的可选参数hint
代表回到的最大字节大小。纵然它当先 0 ,那么再次来到的享有行应有大致有 hint
字节(或然有些大于那个数字,因为急需凑齐缓冲区大小)。

澳门葡京备用网址 4

三、IndexError:索引逾越范围

list1 = [1,2,3]
list1[3]

#IndexError: list index out of range
  • s 学起,保存数据!

2、输出

write(self, s: AnyStr) -> int
writelines(self, lines: List[AnyStr]) -> None

write() 内建艺术效果与 read() 和 readline()
相反。它把带有文本数据或贰进制数据块的字符串写入到文件中去。

和 readlines() 一样,writelines()
方法是对准列表的操作,它接受二个字符串列表作为参数,将 它 们 写 入 文
件。行 结 束 符 并 不 会 被 自 动 加 入,所 以 如 果 需 要 的 话,你 必
须 在 调 用 writelines() 前给每行结尾加上行截至符。

在意那里并未 “writeline()”
方法,因为它等价于使用以行甘休符结尾的单行字符串调用 write() 方法。

四、KeyError:字典中绝非那几个键

list1 = {1:2,3:4}
list1[6]

#KeyError: 6

****************

三、判定是或不是可读可写

readable(self) -> bool
writable(self) -> bool
在Linux系统中总体皆文件,包含硬件装置都虚拟成1个文本,不过有些公文是不可读,所以大家得以采取readable() 方法,判别文件是不是可读。

澳门葡京备用网址 5

小编们得以采纳 writable() 方法来判断一个文件对象是还是不是可写。

5、TypeError:不相同种类间的无效操作

1 + '1'

#TypeError: unsupported operand type(s) for +: 'int' and 'str'

壹、打开文件

四、文件内运动

seek(self, offset: int, whence: int = 0) -> int
seekable(self) -> bool
tell(self) -> int

seek() 方法(类似 C 中的 fseek()
函数)能够在文件中移动文件指针到分裂的任务。offset
字节代表相对于有些地点偏移量,offset 内定的是字节数,acsii
编码一个假名称为1个字节,gbk 编码三个汉字为三个字节,utf-八编码贰个中华夏族民共和国字为二个字节。whence 参数为地点,暗许值为
0,代表从文件开头算起(即相对偏移量),一 代表从当前职责算起,二意味着从文件末尾算起。注意:在文书文件中,未有选用 b
方式选取张开的文件,只允许从文件头初步揣摸相对地方,从别的地点计算时就会掀起这个。尽管你是叁个C 程序员,并且应用过了 fseek(),那么应该驾驭 0,1,2 分别对应着常量
SEEK_SETSEEK_CUR,以及
SEEK_END。当芸芸众生张开文件进行读写操作的时候就会触发到 seek()方法。

我们运用 seek() 方法在文书之中移动,使用 tell()
方法展示大家的活动进程,使用 seekable() 方法推断文件是不是可开展seek 操作。

ZeroDivsionError:除数为零

5 / 0

ZeroDivisionError: division by zero

****************

5、截断

truncate(self, size:int=None)->int
truncate() 暗中认可将当前岗位然后的字符(不包含近期职责)截断(删除地方)。

【2】try-except语句

格式如下:

try:
    检测范围
except Exception [as reason]:
    出现异常的代码

举个例证:

try:
    var = int(input('请输入一个数字:'))
    print(var)
except ValueError:
    print('输入错误')

#请输入一个数字:q
#输入错误   


#当然也可以这样写,错误信息会更加准确    
#except ValueError as reason:
#    print('输入错误,错误原因:'+ str(reason))

在Python中,使用open()这几个函数来开发文件并重临文件对象:help(open)

陆、文件迭代

借使想1行1行的扫描1个文本文件,文件迭代器往往是极品选项。以那种措施编码的时候,open()
一时半刻创办的文本对象将活动在历次循环迭代的时候读入并回到一行。这种样式平常很轻易编写,对于内部存款和储蓄器使用很好,并且比其余选项更加快(当然依照有个别许变量)。

一行一行走访文件非常的粗略:

for eachLine in f:
    pass

在那些轮回里,eachLine
代表文本文件的1行(包含末尾的行截止符),你能够动用它做任何想做的事情。

文件迭代更为快速,而且写(和读)那样的 Python 代码更便于。

澳门葡京备用网址 6

本着不相同的拾一分设置七个except

try:
    var = int(input('请输入一个数字:'))
    rel = var + '1'
    print(rel)
except ValueError as reason:
    print('输入错误,错误原因:'+ str(reason))
except TypeError as reason:
    print('输入错误,错误原因:' + str(reason))


#请输入一个数字:1
#输入错误,错误原因:unsupported operand type(s) for +: 'int' and 'str'    

open(file, mode=’r’, buffering=-1, encoding=None, errors=None,
newline=None, closefd=True, opener=None)

七、把内部存款和储蓄器汉语件的始末刷入到硬盘中

flush(self) -> None
调用文件对象的 flush() 方法能够把内部存款和储蓄器中的文书的剧情写入到硬盘中。

抓获全部越发

try:
    var = int(input('请输入一个数字:'))
    rel = var + '1'
    print(rel)
except:
    print('报错了')

#请输入一个数字:q
#报错了

open()那个函数是有数不尽参数的,但作为初学者的我们,只须求先关怀首先个参数和第二个参数就可以。第1个参数是传播的文件名,若是只有文件名,不带路径的话,那么python会在日前文件夹中去找到该文件并开荒。若是要打开的公文不设有呢?那将在看第贰个参数了,第二个参数钦定张开文件的方式:

八、文件关闭

close(self) -> None
closed(self) -> bool

大家能够调用文件对象的 close()
方法关闭文件来甘休对它的走访。Python
垃圾搜集体制也会在文书对象的引用计数降至零的时候自动关闭文件。那在文书唯有2个引用时发生,比如fp = open(…),然后 fp
在原来的文章件显式地关闭前被赋了另二个文本对象。出色的编制程序习于旧贯供给在再一次赋另个文件对象前关闭那些文件。若是您不显式地关闭文件,那么你恐怕丢掉输出缓冲区的数据。暗中认可境况下,输出文件连续缓冲的,那意味着写入的文件可能不会登时自动从内存转换来硬盘——关闭2个文本,或然运转其
flush() 方法,迫使缓存的数额进入硬盘。

调用 flush()
方法会直接把内部存款和储蓄器缓冲区中的数据及时写入文件,而不是被动地伺机输出缓冲区被写入。使用
closed() 方法判定三个文本对象是还是不是曾经关门了。

【3】try-finally语句

那里我们利用张开文件作为例子,因为文件张开了不管报不报错都急需关闭。

文件操作在继续内容会讲到

try:
    f = open('我是一个不存在的文件.txt') #打开文件
    print(f.read())
except:
    print('出错了')  #在没有finally的时候报错了就会被终止
finally:
    #f.close()   #关闭文件,这里给大家看的,注释去掉会报错
    print('关闭文件成功')  

在try没有报错的情事下,会跳到finally里面实行代码。

try报错了,会执行except,在执行finally。

finally正是确定保证无论怎么着都要被实行的。

打开模式      执行操作
'r'            以只读方式打开文件(默认)
'w'            以写入的方式打开文件,会覆盖已存在的文件
'x'            如果文件已经存在,使用此模式打开将引发异常
'a'            以写入模式打开,如果文件存在,则在末尾追加写入
'b'            以二进制模式打开文件
't'            以文本模式打开(默认)
'+'            可读写模式(可添加到其他模式中使用)
'U'            通用换行符支持

4、标准文件

习认为常,只要您的顺序壹实行,那么你就可以访问多个标准文件。它们分别是标准输入(一般是键盘)、标准输出(到显示器的缓冲输出)和正规错误(到显示器的非缓冲输出)。那里所说的”缓冲”和”非缓冲”是指
open() 函数的第4个参数。那么些文件沿用的是 C
语言中的命名,分别为stdin,stdout 和
stderr。大家说”只要你的主次1实行就足以访问这三个标准文件”,意思是那些文件已经被事先展开了,只要知道它们的文书句柄就能够随时访问那一个文件。

Python 中能够经过 sys 模块来拜会那些文件的句柄。导入 sys
模块然后,就可以采纳sys.stdin,sys.stdout 和 sys.stderr 访问。print()
语句平日是出口到 sys.stdout;而 input() 语句则一般从 sys.stdin
接受输入。

【4】raise语句

它的效率是随时随处抛出贰个相当,能够带参数。

raise ZeroDivisionError

#raise TypeError('类型错误')

运用open成功开荒七个文本后,它会自动回到八个文件对象,得到这一个文件对象,就可以读取可能修改那几个文件:

5、第二方模块

【5】丰富的else语句

那里的else说的不是if-else那个东西。

唯独if-else也能够抛出极度,大家早就玩过了,比方身为不是超乎某些数。

例子:

try:
    int('abc')
except ValueError as reason:
    print('出错了,错误原因是:' + str(reason))
else:
    print('没有问题')

#出错了,错误原因是:invalid literal for int() with base 10: 'abc'

上面的这几个例子else中代码未有实践,因为else是在try中尚无难题的事态下举行的。

>>> #先将record.txt文件放到Python的根目录下(如:C:\Python34)

>>> f = open("record.txt")

>>> 

动用用pickle模块来积存Python的原生对象

壹旦您真的想囤积Python原生对象,但又力不从心相信文件的多寡来源于,Python规范库pickle模块是力所能及让我们平素在文件中存款和储蓄大概任何Python对象的高级工具,并不必要我们吧字符串转换到调换去。

pickle模块实行所谓的对象类别化,也正是目的和字符串之间的并行转换。

澳门葡京备用网址 7

【6】简洁的with语句

大家地方讲过了finally,在文件读取的时候能够用它来关闭文件,想想又要开荒又要关门,太烦人,那么大家的with就足以进场了,在你忘记关闭文件的时候它会自行帮您关上。

try:
    with open('我是一个不存在的文件.txt') as f:
        print(f.read())
except OSError as reason:
    print('挂啦!原因是:' + str(reason))

那般写是或不是福利多了,也就算忘记关闭文件。

未有新闻正是好音信,表示大家的文书被成功开荒了。

文件中封装贰进制数据的存款和储蓄与分析

有点高档应用程序也急需管理打包的贰进制数据,Python的规范库包括的struct模块能够社团并分析打包的二进制数据。从某种意义上说,它是另多少个数目转换工具,它能够把文件中的字符串解读为贰进制数据。

第捌②章


***********************

【一】文件永世远,三个永流传

绝大很多的次序都以依照,输入->管理->输出的模子,首先接受输入数据,然后遵照供给开展管理,最后输出结果。或许今后你的要求就时时刻刻这个了,你恐怕需求您的主次能够去自动的分析系统的日志,然后分析结果在保留作为二个新的日记,那时候就需求选择文件了。

或许说你在IDLE中写程序,突然贰个狼狈,Computer蓝屏了,在开机,你的代码都没了,可是在pycharm中为什么就不会了,因为必必要新建3个文本,然后您写的时候自动储存在文件里,文件是写在硬盘上的。

在你编写代码的时候,操作系统为了更加快的做出响应,会把当前的数据总体保留在内部存款和储蓄器中,因为内部存储器和CPU之间的数量传输是最快的,比硬盘和CPU快多了。不过内部存款和储蓄器的欠缺正是一断电就玩完了。

文件的格式大家也见过多数,windows 的.exe .txt还有大家python
的.py等等,这一个都以文本。
、、

贰、文件对象的点子

字符串类型和字节类型

字符串类型向字节类型转化称之为编码 encode

字节类型向字符串类型转化称之为解码 decode

<font
color=’red’>注意编解码格式一定要保持1致,假诺是程序会报错,假诺是编辑器查看,直接乱码</font>

常用的字符集都以哪些看头

ascii  
    这玩意就是美国搞的一套标准,用的是一个字节,用了其中的0-127表示了所有的老外用的东西
ansi 
    这玩意用两个字节,叫做扩展的ascii码,128-0xffff
gbk  
    扩展的国标,在gb2312的基础上又多了好多的繁体字xxx,兼容gb2312 
gb2312 
    这玩意是中国搞了一套自己编解码(韩国搞了一套自己的、日本也搞了一套自己的)
    对应的中国的ansi 
utf-8   
    互联网兴起了,迫切需要统一的编码,utf-8就在unicode的基础上规定了存储和读取的方式,他存储的时候是变化的,如果存储英文字母,其使用的是1个字节,如果用来存储汉子,占用3个字节
unicode
    是一套国际标准,称之为万国码,也是两个字节
    并没有真正的执行起来,而且也没有规定怎么存储和读取

<font
color=’red’>注意:现在您要用的话,应该都是utf-8无bom的格式,假如碰着了gbk,你要和谐会转接相应的格式</font>

***********************

【贰】展开文件

在python中,使用open()这几个函数来开拓文件重临文件对象:

open(file,mode = ‘r’,buffering = -1,encoding = None,errors =
None,newline = None,closefd = True,opener = None)

open()那几个函数有多数参数,但作为初学者来说,只要求领会首个和第3个参数就能够了。

file:              要打开的文件名,需加路径(除非是在当前目录)。唯一强制参数
mode:              文件打开的模式
buffering:         设置buffer(取值为0,1,>1)
encoding:          返回数据的编码(一般为UTF8或GBK)
errors:            报错级别(一般为strict,ignore)
newline:           用于区分换行符(只对文本模式有效,可以取的值有None,'\n','\r','','\r\n')
closefd:           传入的file参数类型(缺省为True)

mode对照表:

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

例子:

path = r"C:\Users\xlg\Desktop\Python-1704\day07\5-文件读写\file1.txt"
#ignore  忽略错误
#f = open(path, "r", encoding="utf-8", errors="ignore")
f = open(path, "r", encoding="utf-8")

开采完文件并得到文件对象之后,就足以应用文件对象的有个别格局对文本实行读取或修改等操作。如下表列举了有个别文书对象的措施:

【三】文件对象的方式

开荒文件并获取文件对象现在,就足以利用文件对象的有的主意对文本进行读取或修改等操作。

文件对象方法 执行操作
close() 关闭文件
read(size =-1) 从文件读取size个字符,当未给定或者给定负值的时候,读取剩余的所有的字符,然后作为字符返回
reading() 从文件中读取一整行字符
write() 将字符串str写入文件
writelines(seq) 向文件写入字符串序列seq,seq应该是一个返回字符串的可迭代对象
seek(offset,from) 在文件中移入文件指针,从from(0代表文件起始位置,1代表当前位置,2代表文件末尾)偏移offset个字节
tell() 返回当前在文件中的位置
文件对象方法                  执行操作
f.close()                      关闭文件
f.read([size=-1])           从文件读取size个字符,当未给定size或给定负值的时候,读取剩余的所有字符,然后作为字符串返回
f.readline([size=-1])        从文件中读取并返回一行(包括行结束符),如果有size有定义则返回size个字符
f.write(str)                   将字符串str写入文件
f.writelines(seq)           向文件写入字符串序列seq,seq应该是一个返回字符串的可迭代对象
f.seek(offset, from)          在文件中移动文件指针,从from(0代表文件起始位置,1代表当前位置,2代表文件末尾)偏移offset个字节
f.tell()                返回当前在文件中的位置
f.truncate([size=file.tell()])  截取文件到size个字节,默认是截取到文件指针当前位置

【四】文件的关门

close()方法用于关闭文件。假使是C语言的话,小编在此间确定会重申10000次关闭的,假使您不休憩的话,别人想要读写就会不可能完成。不关门文件会产生(other)不恐怕再度已写的章程打开,以前是连只读的章程都非凡。而python具备垃圾回收机制,会在文书对象的引用此计数降至零的时候自动关闭文件。

可是并不表示能够不关门文件,假使你对文件进行写入操作的话,那么相应在形成写入之后关闭文件。因为python恐怕会缓存你写入的多少,假若中途爆发看似断电之类的事故,那三个缓存的多寡根本就不会写入到文件中。所以,为了安全起见,要养成使用完文件后立即关闭的好习于旧贯。

  

【伍】文件的读取和向来

文本的读取方法大多,可以使用文件对象read()和readline()方法,也足以直接list(f)或许直接使用迭代来读取。

read()方法是按字节来的去,假诺不安装字节数,那么集会场全部读取。tell()方法会报告您目前文件的指针地方。

f = open(r'/Users/ruidong/PycharmProjects/project/demo.txt')
print(f.read())
print(f.tell())
f.close()

凑巧提到文件指针是个怎样东西?你能够以为它是1个书签,起到一定的法力。使用seek()方法能够调解文件指针的任务。seek(offset,from)方法有多少个参数。

相当于文件读取了稍稍今后,会转换指针,只可以向后读,不能再读取已度去过的,除非采取seek()重新调节指针。

from  表示从(0代表当前文件起始位置,1代表当前位置,2代表文件末尾)偏移 offset字节。

所以,将文件指针设置到文件开始地方,使用seek(0,0)即可:

f = open(r'/Users/ruidong/PycharmProjects/project/demo.txt')
print(f.read())
print(f.tell())
f.seek(0,0)
print('\n********************\n')
print(f.read())
f.close()

readline()方法用于在文书中读取一整行,正是从文件指针的岗位向后读取,直到遇见换行符(\n)结束。

f = open(r'/Users/ruidong/PycharmProjects/project/demo.txt')
print(f.readline())
print(f.readline())
f.close()

在此之前介绍过列表强大,说什么样都可以后里面放,那不,也得以把整个文件的剧情放到列表中:

f = open(r'/Users/ruidong/PycharmProjects/project/demo.txt')
lines = list(f)
for each_line in lines:
    print(each_line
f.close()

如此写是未有失水准的,然而了以为像是非要用酒精烧热水,水能烧的开,然而功用不高。文件本来正是能够迭代的。

f = open(r'/Users/ruidong/PycharmProjects/project/demo.txt')
for each_line in f:
    print(each_line)
f.close()

******************

【陆】文件的写入

假若供给写入文件,请确认保障在此之前的张开情势有‘w’恐怕‘a’也许多带上‘+’,否者在写入的时候回出错:

open 未有 ‘w’那二个可写入的操作符或报错:

import os
os.system('touch wdemo.txt')  #在当前文件夹下新建一个wdemo.txt文件
f = open(r'/Users/ruidong/PycharmProjects/project/wdemo.txt')
f.write('这是一个神奇的地方')
f.close()

#io.UnsupportedOperation: not writable

应用‘r+’读写格局,不过要专注‘r+’只怕是‘w’会把原本的文本内容给删除。

f = open(r'/Users/ruidong/PycharmProjects/project/wdemo.txt','r+')
f.write('这是一个神奇的地方')
f.close()

如假使增加的话,要不然会促成血淋淋的教训,那就要利用‘a’操作符展开:

f = open(r'/Users/ruidong/PycharmProjects/project/wdemo.txt','a+')
f.write('\n这是一个美丽的地方')
f.close()

将连串单行写入

writelines() 方法用于向文件中写入1系列的字符串。
那壹种类字符串能够是由迭代目的产生的,如三个字符串列表。
换行必要制定换行符 \n。

f = open("wdemo.txt", "w")

seq = ['千锋教育\n','python']
f.writelines(seq)

三、文件的闭馆

刷新缓冲区域

文本在写入的时候斌未有直接写入,而是在内部存款和储蓄器中,唯有我们推行f.close()关闭文件之后,它才会写入。

纵然想不平息文件向来写入,那么使用f.flush(),它的功效是当时将内部存款和储蓄器上的多少写入硬盘。

f = open('wdemo.txt','w')
f.write('niahoa')
f.flush()

******************

close()方法用于关闭文件。Python具有垃圾回收机制,会在文书对象的引用计数降至零的时候自动关闭文件,所以在Python编制程序里,假诺忘记关闭文件并不会形成内存败露那么凶险的结果。

但并不是说就足以不关门文件,要是你对文件实行了写入操作,那么相应在做到写入之后关闭文件。因为Python恐怕会缓存你写入的数目,若是中途发生看似断电之类的事故,那么缓存的数码根本就不会写入到内部存款和储蓄器中。所以,安全起见,要养成使用完文件后马上关闭的好习于旧贯。

**************************

四、文件的读取和固定

**************************

文件的读取方法有无数种,能够行使文件对象的read()和readline()方法,也足以直接list(f)也许直接运用迭代来读取。read()是按字节为单位读取,借使不安装参数,那么会全体读抽取来,文件的指针指向终极。tell()方法能够告诉你目前文件指针的职务:

>>> f.read()

'小客服:小甲鱼,今天有客户问你有没有女朋友?\n小甲鱼:咦??\n小客服:我跟她说你有女朋友了!\n小甲鱼:。。。。。。\n小客服:她让你分手后考虑下她!然后我说:"您要买个优盘,我就帮您留意下~"\n小甲鱼:然后呢?\n小客服:她买了两个,说发一个货就好~\n小甲鱼:呃。。。。。。你真牛!\n小客服:那是,谁让我是鱼C最可爱小客服嘛~\n小甲鱼:下次有人想调戏你我不阻止~\n小客服:滚!!!\n================================================================================\n小客服:小甲鱼,有个好评很好笑哈。\n小甲鱼:哦?\n小客服:"有了小甲鱼,以后妈妈再也不用担心我的学习了~"\n小甲鱼:哈哈哈,我看到丫,我还发微博了呢~\n小客服:嗯嗯,我看了你的微博丫~\n小甲鱼:哟西~\n小客服:那个有条回复“左手拿著小甲魚,右手拿著打火機,哪裡不會點哪裡,so easy ^_^”\n小甲鱼:T_T\n================================================================================\n小客服:小甲鱼,今天一个会员想找你\n小甲鱼:哦?什么事?\n小客服:他说你一个学生月薪已经超过12k了!!\n小甲鱼:哪里的?\n小客服:上海的\n小甲鱼:那正常,哪家公司?\n小客服:他没说呀。\n小甲鱼:哦\n小客服:老大,为什么我工资那么低啊??是时候涨涨工资了!!\n小甲鱼:啊,你说什么?我在外边呢,这里好吵吖。。。。。。\n小客服:滚!!!'
>>> f.tell()

1129

刚刚提到的文书指针是啥?能够以为它是3个”书签“,起到一定的功用。使用seek()方法能够调动文件指针的职位。seek(offset,from)方法有多个参数,表示从from(0代表文件的开局地点,1意味当前位置,2意味文件末尾)偏移offset字节。因而将文件指针设置到胚胎地点,使用sek(0,0)就能够:

>>> f.tell()

1129
>>> f.seek(0,0)

0
>>> f.read(5)

'小客服:小'
>>> f.tell()

9

(注:因为三个汉语字符占用1个字节的上空,所以多少个汉语加上3个英文冒号刚好到地方玖)

readline()方法用于在文书中读取一整行,正是从文件指针的岗位向后读取,直到碰着换行符(\n)结束:

>>> f.readline()

'甲鱼,今天有客户问你有没有女朋友?\n'

在此在此之前牵线过列表的强硬,这不,也得以将整个文件的始末放在列表中:

>>> list(f)

['小甲鱼:咦??\n', '小客服:我跟她说你有女朋友了!\n', '小甲鱼:。。。。。。\n', '小客服:她让你分手后考虑下她!然后我说:"您要买个优盘,我就帮您留意下~"\n', '小甲鱼:然后呢?\n', '小客服:她买了两个,说发一个货就好~\n', '小甲鱼:呃。。。。。。你真牛!\n', '小客服:那是,谁让我是鱼C最可爱小客服嘛~\n', '小甲鱼:下次有人想调戏你我不阻止~\n', '小客服:滚!!!\n', '================================================================================\n', '小客服:小甲鱼,有个好评很好笑哈。\n', '小甲鱼:哦?\n', '小客服:"有了小甲鱼,以后妈妈再也不用担心我的学习了~"\n', '小甲鱼:哈哈哈,我看到丫,我还发微博了呢~\n', '小客服:嗯嗯,我看了你的微博丫~\n', '小甲鱼:哟西~\n', '小客服:那个有条回复“左手拿著小甲魚,右手拿著打火機,哪裡不會點哪裡,so easy ^_^”\n', '小甲鱼:T_T\n', '================================================================================\n', '小客服:小甲鱼,今天一个会员想找你\n', '小甲鱼:哦?什么事?\n', '小客服:他说你一个学生月薪已经超过12k了!!\n', '小甲鱼:哪里的?\n', '小客服:上海的\n', '小甲鱼:那正常,哪家公司?\n', '小客服:他没说呀。\n', '小甲鱼:哦\n', '小客服:老大,为什么我工资那么低啊??是时候涨涨工资了!!\n', '小甲鱼:啊,你说什么?我在外边呢,这里好吵吖。。。。。。\n', '小客服:滚!!!']

对此迭代读取文本文件中的每一行,也许会如此写:

>>> f.seek(0,0)

0
>>> lines = list(f)

>>> for each_line in lines:
       print(each_line)

那样写没错,可是作用不高。因为文件对象自己是支撑迭代的,所以没供给绕圈子,直接选用for语句把内容迭代读抽取来就能够:

>>> f.seek(0,0)

0
>>> for each_line in f:
        print(each_line)


小客服:小甲鱼,今天有客户问你有没有女朋友?

小甲鱼:咦??

小客服:我跟她说你有女朋友了!

小甲鱼:。。。。。。

小客服:她让你分手后考虑下她!然后我说:"您要买个优盘,我就帮您留意下~"

小甲鱼:然后呢?

小客服:她买了两个,说发一个货就好~

小甲鱼:呃。。。。。。你真牛!

小客服:那是,谁让我是鱼C最可爱小客服嘛~

小甲鱼:下次有人想调戏你我不阻止~

小客服:滚!!!

================================================================================

小客服:小甲鱼,有个好评很好笑哈。

小甲鱼:哦?

小客服:"有了小甲鱼,以后妈妈再也不用担心我的学习了~"

小甲鱼:哈哈哈,我看到丫,我还发微博了呢~

小客服:嗯嗯,我看了你的微博丫~

小甲鱼:哟西~

小客服:那个有条回复“左手拿著小甲魚,右手拿著打火機,哪裡不會點哪裡,so easy ^_^”

小甲鱼:T_T

================================================================================

小客服:小甲鱼,今天一个会员想找你

小甲鱼:哦?什么事?

小客服:他说你一个学生月薪已经超过12k了!!

小甲鱼:哪里的?

小客服:上海的

小甲鱼:那正常,哪家公司?

小客服:他没说呀。

小甲鱼:哦

小客服:老大,为什么我工资那么低啊??是时候涨涨工资了!!

小甲鱼:啊,你说什么?我在外边呢,这里好吵吖。。。。。。

小客服:滚!!!

 

******************

5、文件的写入

******************

设若要写入文件,请保管在此以前的展开情势有‘w’或‘a’,不然会出错:

>>> f = open("record.txt")

>>> f.write("这是一段待写入的数据")

Traceback (most recent call last):
  File "<pyshell#31>", line 1, in <module>
    f.write("这是一段待写入的数据")
io.UnsupportedOperation: not writable
>>> f.close()

>>> f = open("record.txt","w")

>>> f.write("这是一段待写入的数据")

10
>>> f.close()

不过,一定要小心的是:使用‘w’形式写入文件,以前的文件内容会被全部排除!!如下图:

澳门葡京备用网址 8

 

*******************************

陆、课时2八课后习题及答案

*******************************

澳门葡京备用网址 9

澳门葡京备用网址 10

澳门葡京备用网址 11

澳门葡京备用网址 12

澳门葡京备用网址 13

澳门葡京备用网址 14

澳门葡京备用网址 15

澳门葡京备用网址 16

 

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website