简明教程之9 IO编程"/>
Python3简明教程之9 IO编程
Python3之IO编程
标准输入输出
打印到屏幕
最简单的输出方法是用print语句,
你可以给它传递零个或多个用逗号隔开的表达式。
此函数把你传递的表达式转换成一个字符串表达式,
并将结果写到标准输出。
例如:
print ("Hello Python")
标准屏幕上会产生以下结果:
读取键盘输入
Python提供了两个内置函数从标准输入读入一行文本,
默认的标准输入是键盘:
raw_input
input
注意:
python3.x系列不再有 raw_input 函数,
python 3.x中 input 和之前的 raw_input 等效
- input函数
input([prompt]) 函数和 raw_input([prompt]) 函数基本类似,
但是 input 可以接收一个Python表达式作为输入,并将运算结果返回。
str = input("please input:")
print ("You input:: ", str)
文件读写
打开和关闭文件
Python 提供了必要的函数和方法进行默认情况下的文件基本操作。
你可以用 file 对象做大部分的文件操作。
open 函数
用Python内置的open()函数打开一个文件,
创建一个file对象,相关的方法才可以调用它进行读写。
语法:
file object = open(file_name [, access_mode][, buffering])
各个参数的细节如下:
file_name:file_name变量是一个包含了要访问的文件名称的字符串值。
access_mode:access_mode决定了打开文件的模式:只读,写入,追加等。
buffering: 如果buffering的值被设为0,就不会有缓存。
模式 | r | r+ | w | w+ | a | a+ |
读 | + | + |
| + |
| + |
写 |
| + | + | + | + | + |
创建 |
|
| + | + | + | + |
覆盖 |
|
| + | + |
|
|
指针在开始 | + | + | + | + |
|
|
指针在结尾 |
|
|
|
| + | + |
File对象的属性
file对象相关的所有属性的列表:
属性 | 描述 |
file.closed | 返回true如果文件已被关闭,否则返回false |
file.mode | 返回被打开文件的访问模式 |
file.name | 返回文件的名称 |
close()方法
File 对象的 close()方法刷新缓冲区里尚未写入硬盘的信息,
并关闭该文件,这之后便不能再进行写入,
用 close()方法关闭文件是一个很好的习惯。
语法:
fileObject.close()
分析:
当我们写文件时,操作系统往往不会立刻把数据写入磁盘,
而是放到内存缓存起来,空闲的时候再慢慢写入。
只有调用close()方法时,操作系统才保证把没有写入的数据全部写入磁盘。
忘记调用close()的后果是数据可能只写了一部分到磁盘,剩下的丢失了。
try:
f = open('xxx.txt', 'r')
print(f.read())
finally:
if f:
f.close()
with语句
语法:“with open … as …”
with open('test.txt', 'w') as ff:
ff.write('Hello, world!')
分析:
由于文件读写时都有可能产生IOError,
一旦出错,后面的f.close()就不会调用。
而try…finally机制又比较繁琐。
Python引入了with语句来自动帮我们调用close()方法:
write()方法
write()方法可将任何字符串写入一个打开的文件。
需要重点注意的是,Python字符串可以是二进制数据,而不是仅仅是文字。
write()方法不会在字符串的结尾添加换行符('\n'):
语法:
fileObject.write(string);
在这里,被传递的参数是要写入到已打开文件的内容。
例子:
# !/usr/bin/python
# -*- coding: UTF-8 -*-
# 打开一个文件
fo = open("test10.txt", "w")
fo.write("www.freencre!\nvery good, thank you.\n");
# 关闭打开的文件
fo.close()
上述方法会创建foo.txt文件,并将收到的内容写入该文件,并最终关闭文件。
如果你打开这个文件,将看到以下内容:
www.freencre!
very good, thank you.
read()方法
read()方法从一个打开的文件中读取一个字符串。
需要重点注意的是,Python字符串可以是二进制数据,而不是仅仅是文字。
语法:
fileObject.read([count])
在这里,被传递的参数是要从已打开文件中读取的字节数。
该方法从文件的开头开始读入,如果没有传入count,
它会尝试尽可能多地读取更多的内容,很可能是直到文件的末尾。
例子:
这里我们用到以上创建的 test10.txt 文件。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 打开一个文件
fo = open("test10.txt", "r+")
str = fo.read(12);
print("读取的字符串是:", str)
# 关闭打开的文件
fo.close()
以上实例输出结果:
读取的字符串是: www.freencre
文件定位
tell()方法返回文件内的当前位置;
seek(offset [,from])方法改变当前文件的位置。
Offset变量表示要移动的字节数,
From变量指定开始移动字节的参考位置:
0:将文件的开头作为移动字节的参考位置。
1:则使用当前的位置作为参考位置。
2:将文件的末尾将作为参考位置。
例子:
就用我们上面创建的文件test10.txt。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 打开一个文件
fo = open("test10.txt", "r+")
str = fo.read(12);
print( "读取的字符串是 : ", str)
# 查找当前位置
position = fo.tell();
print( "当前文件位置 : ", position)
# 把指针再次重新定位到文件开头
position = fo.seek(0, 0);
str = fo.read(10);
print( "重新读取字符串 : ", str)
# 关闭打开的文件
fo.close()
以上实例输出结果:
读取的字符串是 : www.freencre
当前文件位置 : 12
重新读取字符串 : www.freencre
重命名和删除文件
Python的os模块提供了执行文件处理操作的方法,比如重命名和删除文件。
要使用这个模块,你必须先导入它,然后才可以调用相关的各种功能。
- rename()方法:
rename()方法需要两个参数,当前的文件名和新文件名。
语法:
os.rename(current_file_name, new_file_name)
例子:
下例将重命名一个已经存在的文件test1.txt。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import os
# 重命名文件test1.txt到test2.txt。
os.rename( "test1.txt", "test2.txt" )
- remove()方法
可以用remove()方法删除文件,
需要提供要删除的文件名作为参数。
语法:
os.remove(file_name)
例子:
下例将删除一个已经存在的文件test2.txt。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import os
# 删除一个已经存在的文件test2.txt
os.remove("test2.txt")
Python里的目录:
所有文件都包含在各个不同的目录下,不过Python也能轻松处理。
os模块有许多方法能帮你创建,删除和更改目录。
mkdir()方法
可以使用os模块的mkdir()方法在当前目录下创建新的目录们。
你需要提供一个包含了要创建的目录名称的参数。
语法:
os.mkdir("newdir")
例子:
下例将在当前目录下创建一个新目录test。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import os
# 创建目录test
os.mkdir("test")
chdir()方法
可以用chdir()方法来改变当前的目录。
chdir()方法需要的一个参数是你想设成当前目录的目录名称。
语法:
os.chdir("newdir")
例子:
下例将进入"/home/newdir"目录。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import os
# 将当前目录改为" c:/windows "
os.chdir("c:/windows")
getcwd()方法:
getcwd()方法显示当前的工作目录。
语法:
os.getcwd()
例子:
下例给出当前目录:
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import os
# 给出当前的目录
Print(“当前目录”, os.getcwd() )
输出:
当前目录 E:\awork\_pycharmprojects\python3\com\freencre\io
rmdir()方法
rmdir()方法删除目录,目录名称以参数传递。
在删除这个目录之前,它的所有内容应该先被清除。
语法:
os.rmdir('dirname')
注意:
必须确保要删除的目录为空。
否则报异常“OSError: [WinError 145] 目录不是空的。: './test'”
例子:
删除当前目录下的”test”目录
目录的完全合规的名称必须被给出,否则会在当前目录下搜索该目录。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import os
# 删除当前目录下的”test”目录
os.rmdir("./test")
print('rmdir ok.')
StringIO和BytesIO
StringIO和BytesIO是在内存中操作“字符串”和“二级制数据”的方法,
使得和读写文件具有一致的接口。
StringIO
很多时候,数据读写不一定是文件,也可以在内存中读写。
StringIO顾名思义就是在内存中读写字符串。
- 写入StringIO:
第1步:创建StringIO对象
第2步:写入字符串:f.write(…)
第3步:获取写入后的字符串:f.getvalue()
要把str写入StringIO,我们需要先创建一个StringIO,
然后,像文件一样写入即可:
getvalue()方法用于获得写入后的str
>>> from io import StringIO
>>> f = StringIO()
>>> f.write('hello')
5
>>> f.write(' ')
1
>>> f.write('world!')
6
>>> print(f.getvalue())
hello world!
- 读取StringIO
可以用一个str初始化StringIO,然后,像读文件一样读取:
strip()函数:
Python strip() 方法用于移除字符串头尾指定的字符(默认为空格)。
返回移除字符串头尾指定的字符生成的新字符串。
>>> from io import StringIO
>>> f = StringIO('Hello!\nWorld!\nGoodbye!')
>>> while True:
... s = f.readline()
... if s == '':
... break
... print(s.strip())
...
Hello!
World!
Goodbye!
BytesIO
StringIO操作的只能是字符串str,
如果要操作二进制数据,就需要使用BytesIO。
BytesIO实现了在内存中读写bytes,
- 写入BytesIO:
我们创建一个BytesIO,然后写入一些bytes:
>>> from io import BytesIO
>>> f = BytesIO()
>>> f.write('您好'.encode('utf-8'))
6
>>> print(f.getvalue())
b'\xe6\x82\xa8\xe5\xa5\xbd'
请注意,写入的不是str,而是经过UTF-8编码的bytes。
- 读取BytesIO:
和StringIO类似,可以用一个bytes初始化BytesIO,
然后,像读文件一样读取:
>>> from io import BytesIO
>>> f = BytesIO(b'\xe6\x82\xa8\xe5\xa5\xbd')
>>> print(f.read().decode('utf-8'))
您好
操作文件和目录
XML数据解析
XML简介
XML 指可扩展标记语言(eXtensible Markup Language),
标准通用标记语言的子集,
是一种用于标记电子文件使其具有结构性的标记语言。
XML被设计用来传输和存储数据。
XML是一套定义语义标记的规则,
这些标记将文档分成许多部件并对这些部件加以标识。
它也是元标记语言,
即定义了用于定义其他与特定领域有关的、
语义的、结构化的标记语言的句法语言。
python对XML的解析
常见的XML编程接口有DOM和SAX,
这两种接口处理XML文件的方式不同。
python有三种方法解析XML:SAX,DOM,以及ElementTree:
- SAX (simple API for XML )
python 标准库包含SAX解析器,
SAX用事件驱动模型,
通过在解析XML的过程中触发一个个的事件
并调用用户定义的回调函数来处理XML文件。
- DOM(Document Object Model)
将XML数据在内存中解析成一个树,通过对树的操作来操作XML。
- XML实例文件books.xml
本章节使用到的XML实例文件books.xml内容如下:
<collection shelf="New Books">
<book title="Python Programming">
<author>Bill Gates</author>
<year>2003</year>
<price>52.15</price>
<description>introduction for magic python…</description>
</book>
<book title="Java Programming">
<author>Kral Max</author>
<year>2008</year>
<price>35.00</price>
<description>introduction for magic java…</description>
</book>
</collection>
使用SAX解析xml
- SAX是一种基于事件驱动的API:
利用SAX解析XML文档需要:解析器和事件处理器。
解析器负责读取XML文档,并向事件处理器发送事件
事件处理器则负责对事件作出响应,对传递的XML数据进行处理。
使用的场景:
1、对大型文件进行处理;
2、只需要文件的部分内容,或者只需从文件中得到特定信息。
3、想建立自己的对象模型的时候。
- 在python中使用sax方式处理xml:
要先引入xml.sax中的parse函数,
还有xml.sax.handler中的ContentHandler。
- 调用时机:
从行开始,遇到标签之前,存在字符,content的值为这些字符串。
从一个标签,遇到下一个标签之前, 存在字符,content的值为这些字符串。
从一个标签,遇到行结束符之前,存在字符,content的值为这些字符串。
标签可以是开始标签,也可以是结束标签。
startDocument()方法
文档启动的时候调用。
endDocument()方法
解析器到达文档结尾时调用。
startElement(name, attrs)方法
遇到XML开始标签时调用,name是标签的名字,attrs是标签的属性值字典。
endElement(name)方法
遇到XML结束标签时调用。
make_parser方法
以下方法创建一个新的解析器对象并返回。
xml.sax.make_parser( [parser_list] )
parser方法
以下方法创建一个 SAX 解析器并解析xml文档:
xml.sax.parse( xmlfile, contenthandler[, errorhandler])
参数说明:
xmlfile - xml文件名
contenthandler - 必须是一个ContentHandler的对象
使用DOM解析xml
文件对象模型(Document Object Model,简称DOM),
是W3C组织推荐的处理可扩展置标语言的标准编程接口。
一个 DOM 的解析器在解析一个 XML 文档时,
一次性读取整个文档,
把文档中所有元素保存在内存中的一个树结构里,
之后你可以利用DOM 提供的不同的函数来读取
或修改文档的内容和结构,
也可以把修改过的内容写入xml文件。
python中用xml.dom.minidom来解析xml文件,实例如下:
# 使用minidom解析器打开 XML 文档
DOMTree = xml.dom.minidom.parse("books.xml")
collection = DOMTree.documentElement
if collection.hasAttribute("shelf"):
print ("Root element : %s" % collection.getAttribute("shelf"))
# 在集合中获取所有图书
books = collection.getElementsByTagName("book")
# 打印详细信息
for book in books:
print ("*****Book*****")
if book.hasAttribute("title"):
print ("Title: %s" % book.getAttribute("title"))
author = book.getElementsByTagName('author')[0]
print("author: %s" % author.childNodes[0].data)
以上程序执行结果如下:
JSON 数据解析
Python3 JSON 数据解析
JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式。
它基于ECMAScript的一个子集。
Python3 中可以使用 json 模块来对 JSON 数据进行编解码,
它包含了两个函数:
json.dumps(): 对数据进行编码。
json.loads(): 对数据进行解码。
在json的编解码过程中,
python 的原始类型与json类型会相互转换,
具体的转化对照如下:
Python 编码为 JSON 类型转换对应表:
Python | JSON |
dict | object |
list, tuple | array |
str | string |
int, float, int- & float-derived Enums | number |
True | true |
False | false |
None | null |
JSON 解码为 Python 类型转换对应表:
JSON | Python |
object | dict |
array | list |
string | str |
number (int) | int |
number (real) | float |
true | True |
false | False |
null | None |
Python 数据结构转换为JSON
json.dumps 与 json.loads 实例
以下实例演示了 Python 数据结构转换为JSON:
#!/usr/bin/python3
import json
# Python 字典类型转换为 JSON 对象
data = {
'no' : 1,
'name' : 'IT培训,永久免费',
'url' : ''
}
json_str = json.dumps(data)
print ("Python 原始数据:", repr(data))
print ("JSON 对象:", json_str)
执行以上代码输出结果为:
Python 原始数据: {'no': 1, 'name': 'IT培训,永久免费', 'url': ''}
JSON 对象: {"no": 1, "name": "IT\u57f9\u8bad\uff0c\u6c38\u4e45\u514d\u8d39", "url": ""}
通过输出的结果可以看出,
简单类型通过编码后跟其原始的repr()输出结果非常相似。
JSON编码的字符串转为Python数据结构
可以将一个JSON编码的字符串转换回一个Python数据结构:
#!/usr/bin/python3
import json
# Python 字典类型转换为 JSON 对象
data1 = {
'no' : 1,
'name' : ' IT培训,永久免费',
'url' : 'http://www.freencre'
}
json_str = json.dumps(data1)
print ("Python 原始数据:", repr(data1))
print ("JSON 对象:", json_str)
# 将 JSON 对象转换为 Python 字典
data2 = json.loads(json_str)
print ("data2['name']: ", data2['name'])
print ("data2['url']: ", data2['url'])
执行以上代码输出结果为:
Python 原始数据: {'no': 1, 'name': ' IT培训,永久免费', 'url': ''}
JSON 对象: {"no": 1, "name": " IT\u57f9\u8bad\uff0c\u6c38\u4e45\u514d\u8d39", "url": ""}
data2['name']: IT培训,永久免费
data2['url']:
序列化
Python序列化和反序列化
通过将对象序列化可以将其存储在变量或者文件中,
可以保存当时对象的状态,实现其生命周期的延长。
并且需要时可以再次将这个对象读取出来。
Python中有几个常用模块可实现这一功能。
pickle模块
- 存储在变量中
dumps(obj)返回存入的字节
dic = {'age': 23, 'job': 'student'}
byte_data = pickle.dumps(dic)
# out -> b'\x80\x03}q\x00(X\x03\x00\x00\...'
print(byte_data)
- 读取数据
数据以字节保存在了byte_data变量中,
需要再次使用的时候使用loads函数就行了。
obj = pickle.loads(byte_data)
print(obj)
存储在文件中
也可以存在文件中,使得对象持久化。
使用的是dump和load函数,注意和上面的区别,少了s。
由于pickle写入的是二进制数据,
所以打开方式需要以wb和rb的模式。
- 文件方式序列化
with open('abc.pkl', 'wb') as f:
dic = {'age': 23, 'job': 'student'}
pickle.dump(dic, f)
- 文件方式反序列化
with open('abc.pkl', 'rb') as f:
aa = pickle.load(f)
print(aa)
print(type(aa)) # <class 'dict'>
json模块
pickle可以很方便地序列化所有对象。
不过json作为更为标准的格式,
具有更好的可读性(pickle是二进制数据)和跨平台性。
json使用的四个函数名和pickle一致。
- 序列化为字符串
dic = {'age': 23, 'job': 'student'}
dic_str = json.dumps(dic)
print(type(dic_str), dic_str)
# out: <class 'str'> {"age": 23, "job": "student"}
- 反序列化为对象
dic_obj = json.loads(dic_str)
print(type(dic_obj), dic_obj)
# out: <class 'dict'> {'age': 23, 'job': 'student'}
可以看到,
dumps函数将对象转换成了字符串。
loads函数又将其恢复成字典。
- 存储为json文件
dic = {'age': 23, 'job': 'student'}
with open('abc.json', 'w', encoding='utf-8') as f:
json.dump(dic, f)
- 从json文件中恢复出python对象
with open('abc.json', encoding='utf-8') as f:
obj = json.load(f)
print(obj)
更多推荐
Python3简明教程之9 IO编程
发布评论