因为懂你,Python基础手册一伍

By admin in 4858.com on 2019年4月23日

目录:

1、文件对象

文件对象是Python代码访问、操作磁盘上文件的重大接口。文件对象不仅能够用来拜会普通的磁盘文件,而且也足以访问任何别的连串抽象层面上的
“文件”。1旦设置了格外的”钩子”,你就足以访问具备文件类型接口的别的对象,就象是访问的是普普通通文书1律。进行那种肤浅管理的首要缘由是无数的输入/输出数据结构更趋向于使用通用的接口。那样就能够在程序作为和兑现上保证一致性。

文件只是连连的字节系列(字符串),数据的传导平常会用到字节流,无论字节流是由单个字节依旧大块数据整合。对Python来讲,文件的始末总是字符串,无随想件包涵的多寡是怎么项目。

前言

前方几节干燥的模块终于停止了,想要完全领悟前几节的模块须求不断的操练才行,毕竟眼过千遍比不上手过1次嘛。在局地类型供给里,要对文件举行IO操作,毕竟主要数据不容许打字与印刷到显示屏上而不去保存,Python对的公文IO操作并不是很复杂,相信您飞快就能垄断它!

Lesson_7


  1、展开文件

2、内建函数 open()

从没一定的常量语法(约等于想成立列表那样采纳标记表明式
[ ])创设文件对象。要开创二个文书对象,必要调用内建函数 open()
,内建函数 open() 提供了早先化输入/输出(I/O)操作的通用接口。 open()
内建函数成功开荒文件后时候会回去七个文书对象,对该公文进行后继相关的操作都要用到这一个目标,展开不成功会掀起一个
IOError
万分。成功重回的文本对象足以视作Computer上的3个文本链接,你能够经过调用再次来到的文书对象的法子来读写相关外部文件。

文件IO操作

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

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

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

【3】装饰器和生成器

  二、文件对象的秘技

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

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

file
是含有要开拓的文本名字的字符串,它能够是绝对路径或许相对路径。没有目录路线时,文件假定存在于目前的行事目录中(也正是本子运维的地方)。

可选变量 因为懂你,Python基础手册一伍。mode 也是2个字符串,代表文件展开的方式,暗中同意为
'r'。平日,文件使用方式 'r''w',或是 'a'
形式来开拓,分别表示读取,写入和扩张。还有个 'U'
格局,代表通用换行符援助。在方式字符串尾部加上 'b'
,能够张开二进制数据管理。加上 '+' 意味着同时以读写形式张开文件。

选择 ‘r’ 或 ‘U’ 格局展开的公文必须是已经存在的。使用 ‘w’
形式打开的文书若存在则第叁清空,然后(重新)创立。以 ‘a’
情势展开的文件是为扩大数据作准备的,全数写入的多寡都将扩张到文件的最后,纵然你
seek 到了其余的地点。假若文件不设有,将被自动创立,类似以 ‘w’
形式张开文件。

其它二个可选参数 buffering 用于提示访问文件所运用的缓冲格局。在那之中
0 表示不缓冲,1 表示只缓冲壹行数据,任何别的大于 一的值代表行使给定值作为缓冲区大小。不提供该参数大概给定负值代表行使系统暗中同意缓冲机制,既对别的类电报机(
tty
)设备采取行缓冲,其余设备使用正规缓冲。一般景况下利用系统暗中同意情势就能够。

encoding 参数能够钦命大家开发文件所选拔的编码方式,比方 utf-8
或者
gbk。请确认保证使用文件本人的编码形式展开,不然会冒出乱码,贰进制文件默许生成
bytes 字符串类型,无法内定 encoding 参数。

只要您不明白文书的编码,能够应用第1方的 chardet 模块的
detect() 函数来赞助猜想文件的编码格式。使用detect()
函数,你须要首先应用
‘rb’情势相当于以二进制模型张开文件,然后文件中读取的bytes格式的字符串传递给detect()函数,detect()
函数会将测度的结果作为函数的结果回到。

4858.com 1

回去的 confidence
提出了剖断的可信程度,encoding提出了那几个函数判定的文书的编码格式。

1. 开发文件

Python获得文件句柄的措施与c及其类似,使用内置函数open(file, mode=’r’,
buffering=-壹, 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+                                           二进制追加读

这几个形式类似复杂,其实其中规律很清晰,接下去将用文件的读和写来充裕明白那么些形式

生成器

我们知晓通过列表生成式,大家得以一向成立列表。不过了会遭到内部存款和储蓄器的限定,列表容积分明是受限制的。而且,成立二个分包100元个成分的列表,不仅占用内部存款和储蓄器空间,要是大家只是必要拜访前面多少个因素,那前边绝大多素元素占用的空中白白浪费了。

故而,若是列表成分得以依据某种算法推算出来的话,那大家是否可以在循环的经过中不止推算出后续的要素呢?那样就无需成立完整的list,从而节省大批量的空间。在python中,那一种①边循环壹边妄图的的建制,称为生成器(generator)。

首先类:生成器函数:依旧利用 def
定义函数,不过,使用yield而不是return语句重回结果。yield语句一回回到1个结果,在每一种结果中间,挂起函数的动静,以便下次从它离开的地点继续实施。

如下案例加以证实:

# 使用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对小括号()。不过,生成器表达式是按需产生1个生成器结果对象,要想得到每二个因素,就要求循环遍历。

正如案例加以证实:

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() 「读取文件指针之后的保有内容,并回到字符串」

此地提到了1个新定义:文件指针,想象一下,你在翻阅,你的指头指着你正在读的地方,你没读三个字,你的手指头就接着向后动一下,你的指头就是文本指针,以上情势中,除了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   ...:轻轻的我走了,正如我轻轻的来;我轻轻的招手,作别西天的云彩。----那河畔的金柳,(将后面的输出省略了)

装饰器

内衣能够遮羞,可是到了冰冷的时节它不大概抵挡严寒,于是聪明的人类发明了棉衣棉裤,给大家提供了保暖的作用,装饰器就像是棉衣棉裤一样,在不影响内衣的效益下,还能够给我们提供另1种成效.

概念:是多个闭包,把1个函数当做参数,重回贰个代替版的函数,本质上正是1个回到函数的函数

简言之的装饰器

#简单的装饰器
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)

  4、文件的读取和固定

此间是一对开垦文件的例证:

fp = open(‘/etc/motd’) # 以读方式张开
fp = open(‘test’, ‘w’) # 以写情势展开
fp = open(‘data’, ‘r+’) # 以读写情势展开
fp = open(r’c:\io.sys’, ‘rb’) # 以二进制读方式张开

4858.com 2

在别的情状下,Python程序中管理的文本格式文件都选择字符串的样式。读取文件时会再次回到字符串格局的公文,文本作为字符串传递给
write()
方法。Python不会再接再砺把对象转变为字符串——你不可能不传递三个已经格式化的字符串。

三. 文书的写

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进制的

4858.com,  伍、文件的写入

文件文件和2进制文件

在Python 三粤语件类型都由 open() 函数的第一个参数决定,形式字符串包含一个’b’
表示以二进制格式展开。Python总是协助文件文件和二进制文件。文本文件把内容表示为常规的
str 字符串,自动实行 Unicode
编码和平消除码,并且暗中认可执行末行调换。2进制文件把内容表示为一个独特的 bytes
字符串类型,并且同意程序不变的造访文件内容。

普通,你必须利用 bytes 字符串处理②进制文件,使用正规的 str
字符串管理公事文件。其余,由于文本文件贯彻了Unicode编码,不可能以文件格局张开2个2进制数据文件,这样会将其内容解码为Unicode文本,生成乱码,导致战败。此外2进制格局不会对数据实践其它末行转换,他径直读取硬盘中文件保存的2进制(0101)并以十6进制的格式展现。

四. 闭馆文件

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

In [48]: f.close()

第八一章


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

通用换行符协助(UNS)

今非昔比平台用来代表行终止的号子是差异的,比方 \n,\r,或者
\r\n。所以,Python
的解释器也要拍卖那样的天职,特别是在导入模块时那些主要。

那正是 UNS 的关键所在,作为 PEP 27八 的结果,Python 二.叁 引进了
UNS。当你使用 ‘U’
标记张开文件的时候,全部的行分割符(或行停止符,无论它原本是什么样)通过
Python 的输入方法(例如 read*() )再次来到时都会被替换为换行符
NEWLINE(\n)。(‘rU’ 方式也支撑 ‘rb’ 选项)
。这么些特点还接济包罗区别体系行甘休符的文件。文件对象的 newlines
属性会记录它曾“看到的”文件的行结束符。

借使文件刚被张开,程序还从未越过行甘休符,那么文件的 newlines 为
None。在第二行被读取后,它被安装为第3行的终止符。借使遇上别的类型的行甘休符,文件的
newlines 会成为3个涵盖各个格式的元组。注意 UNS
只用于读取文本文件。未有对应的管理公事输出的办法。在编写翻译 Python
的时候,UNS 默许是展开的。若是您不必要以此性子,在运维 configure
脚本时,你可以行使 –without-universal-newlines
开关关闭它。倘诺你非要自身管理行截至符,使用 os 模块的有关属性。

伍. 文书其他措施

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

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

name 「再次来到当前文件名」

【一】你不大概总是对的

大家是人,不是神,所以大家平时会犯错,即便你是个经验丰富的工程师,也不能够有限支撑你写的代码百分百的远非难点。

其余作为1个及格的程序猿,再编制程序的时候你要铭记一点,正是世代都毫不相信您的用户。要把他们想象成熊孩子,把她们想象成黑客,那样你才能写出平安稳固性的顺序。

作者们看例子:

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

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

上边那个例子就报错了ValueError万分,那么python会抛出那多少个可怜了

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

 

应用 with open 张开文件,代码块施行完,文件都自动关闭

4858.com 3

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

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

它在基准不树立的景色下抛出 AssertionError

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

#请输入一个数字100
#AssertionError

绝大大多程序都依照着:输入->处理->输出的模子,首先接受输入数据,然后遵照要求开始展览管理,最后输出结果。未来大家不再只满意使用input接受用户的输入,使用print输出管理的结果了。大家急迫想要关切到系统的满贯,用代码自动分析种类的日志,分析的结果能够保留为七个新的日记,乃至足以跟外界的世界进行沟通。

三、文件对象的内建方式

open()
成功实施并赶回1个文书对象之后,全数对该公文的三番5遍操作都将经过那几个”句柄”(文件对象)实行。文件方式可以分为肆类:输入,输出,文件内活动,以及杂项操作。

贰、AttributeError:尝试访问地方的目的属性

当试图访问的目的属性不存在时抛出非常:

list1 = []
list1.shanghai

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

在编写程序的时候,操作系统为了更加快的做出响应,把具备当前的数额都放在内部存储器中。但内部存款和储蓄器有个自然的供不应求,1断点就没戏,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()
方法读取展开文件的1行(读取下个行终止符在此之前的享有字节)。然后整行(包涵行终止符)作为字符串再次来到。和
read() 一样,它也有二个可选的 limit 参数,私下认可为-一,代表读至行停止符。要是提供了该参数,那么在赶过 limit
个字节后会重返不完整的行。

readlines()
方法并不像其余七个输入方法壹致重临3个字符串。它会读取全体(剩余的)行然后把它们当做1个字符串列表再次来到。它的可选参数hint
代表回到的最大字节大小。要是它高于 0 ,那么再次来到的有着行应有差不离有 hint
字节(大概有点大于这么些数字,因为需求凑齐缓冲区大小)。

4858.com 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()
方法是本着列表的操作,它承受3个字符串列表作为参数,将 它 们 写 入 文
件。行 结 束 符 并 不 会 被 自 动 加 入,所 以 如 果 需 要 的 话,你 必
须 在 调 用 writelines() 前给每行结尾加上行截止符。

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

肆、KeyError:字典中从未那些键

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

#KeyError: 6

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

三、推断是不是可读可写

readable(self) -> bool
writable(self) -> bool
在Linux系统中任何皆文件,包涵硬件设施都虚拟成二个文本,但是多少公文是不可读,所以大家可以使用
readable() 方法,判别文件是或不是可读。

4858.com 5

我们得以动用 writable() 方法来判定2个文书对象是还是不是可写。

伍、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
编码多少个假名称为二个字节,gbk 编码二当中夏族民共和国字为一个字节,utf-8编码一个汉字为3个字节。whence 参数为地方,私下认可值为
0,代表从文件初叶算起(即相对偏移量),一 意味着从当前职分算起,2意味从文件末尾算起。注意:在文书文件中,未有运用 b
方式选拔展开的文书,只同意从文件头先导臆想相对地方,从此外岗位总结时就会掀起那么些。假诺您是一个C 程序猿,并且利用过了 fseek(),那么应该明白 0,一,二 分别对应着常量
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()
临时创办的文件对象将自动在每一趟循环迭代的时候读入并回到一行。那种情势常常很轻易编写,对于内存使用很好,并且比其它选项越来越快(当然依照有稍许变量)。

一行1行访问文件很轻松:

for eachLine in f:
    pass

在这几个轮回里,eachLine
代表文本文件的一行(包涵末尾的行甘休符),你能够利用它做其余想做的政工。

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

4858.com 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)

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

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

破获全部越发

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

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

open()那一个函数是有数不清参数的,但作为初学者的大家,只须要先关怀首先个参数和第一个参数就能够。第壹个参数是流传的文书名,如若唯有文件名,不带路线的话,那么python会在当下文件夹中去找到该公文并打开。假诺要开辟的文件不存在呢?那就要看第二个参数了,第四个参数钦点张开文件的方式:

八、文件关闭

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

我们能够调用文件对象的 close()
方法关闭文件来甘休对它的访问。Python
垃圾搜集体制也会在文件对象的引用计数降至零的时候自动关闭文件。这在文书唯有一个引用时爆发,例如fp = open(…),然后 fp
在原版的书文件显式地关闭前被赋了另四个文件对象。优秀的编制程序习贯供给在重复赋另个文本对象前关闭这么些文件。就算你不显式地关闭文件,那么您可能有失输出缓冲区的多寡。默许情状下,输出文件接二连三缓冲的,这意味写入的公文恐怕不会立即自动从内部存储器转变成硬盘——关闭一个文书,可能运维其
flush() 方法,迫使缓存的数码进入硬盘。

调用 flush()
方法会直接把内部存款和储蓄器缓冲区中的数据及时写入文件,而不是庸庸碌碌地等候输出缓冲区被写入。使用
closed() 方法判定2个文书对象是否已经关闭了。

【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、标准文件

平时,只要你的次序1进行,那么你就足以访问多少个标准文件。它们各自是明媒正娶输入(一般是键盘)、标准输出(到显示屏的缓冲输出)和规范错误(到显示器的非缓冲输出)。这里所说的”缓冲”和”非缓冲”是指
open() 函数的第几个参数。那一个文件沿用的是 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模块施行所谓的靶子体系化,也正是指标和字符串之间的并行调换。

4858.com 7

【6】简洁的with语句

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

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

那样写是还是不是便利多了,也不怕忘记关闭文件。

未曾音信正是好音信,表示大家的公文被成功开辟了。

文件中封装二进制数据的积累与分析

些微高端应用程序也亟需管理打包的贰进制数据,Python的标准库包蕴的struct模块能够协会并分析打包的二进制数据。从某种意义上说,它是另2个多少转换工具,它能够把公文中的字符串解读为二进制数据。

第玖二章


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

【1】文件永恒远,一个永流传

诸多的先后都是遵守,输入->管理->输出的模子,首先接受输入数据,然后依据需求开始展览管理,最后输出结果。也许未来你的供给就不绝于耳这个了,你恐怕须求您的顺序能够去自动的分析系统的日记,然后分析结果在保留作为贰个新的日志,那时候就必要使用文件了。

恐怕说你在IDLE中写程序,突然1个畸形,计算机蓝屏了,在开机,你的代码都没了,但是在pycharm中缘何就不会了,因为须要求新建一个文件,然后你写的时候自动积攒在文书里,文件是写在硬盘上的。

在您编写代码的时候,操作系统为了越来越快的做出响应,会把近来的数额总体封存在内存中,因为内部存款和储蓄器和CPU之间的多少传输是最快的,比硬盘和CPU快多了。不过内部存款和储蓄器的欠缺正是一断电就玩完了。

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

2、文件对象的法子

字符串类型和字节类型

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

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

<font
color=’red’>注意编解码格式一定要保持一致,假诺是程序会报错,要是是编辑器查看,间接乱码</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()这一个函数有成都百货上千参数,但作为初学者来说,只要求驾驭第2个和第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")

展开完文件并赢得文件对象之后,就能够选择文件对象的一些形式对文件实行读取或修改等操作。如下表列举了1部分文本对象的秘籍:

【3】文件对象的不二法门

开采文件并获得文件对象以往,就能够利用文件对象的局地格局对文本实行读取或修改等操作。

文件对象方法 执行操作
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语言的话,作者在那里一定会重申30000次关闭的,假如你不停业的话,旁人想要读写就会不可能到位
。不苏息文件会促成(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()

恰巧提到文件指针是个什么玩意儿?你能够以为它是三个书签,起到稳固的功力。使用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()方法用于在文书中读取1整行,就是从文件指针的岗位向后读取,直到碰着换行符(\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()

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

【六】文件的写入

万1须要写入文件,请确认保障此前的打开格局有‘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() 方法用于向文件中写入一连串的字符串。
这一种类字符串能够是由迭代目标发生的,如一个字符串列表。
换行须求制订换行符 \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

刚才提到的公文指针是甚?可以认为它是一个”书签“,起到稳固的功能。使用seek()方法能够调节文件指针的岗位。seek(offset,from)方法有五个参数,表示从from(0代表文件的发端地点,1象征当前职务,二象征文件末尾)偏移offset字节。由此将文件指针设置到开首位置,使用sek(0,0)就能够:

>>> f.tell()

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

0
>>> f.read(5)

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

9

(注:因为三个华语字符占用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了!!

小甲鱼:哪里的?

小客服:上海的

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

小客服:他没说呀。

小甲鱼:哦

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

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

小客服:滚!!!

 

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

伍、文件的写入

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

假诺要写入文件,请确定保证在此以前的开发格局有‘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’格局写入文件,在此以前的文件内容会被全体拔除!!如下图:

4858.com 8

 

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

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

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

4858.com 9

4858.com 10

4858.com 11

4858.com 12

4858.com 13

4858.com 14

4858.com 15

4858.com 16

 

发表评论

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

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有