Python3简明教程之9 IO编程

 

 

 

Python3之IO编程

标准输入输出

打印到屏幕

最简单的输出方法是用print语句，

你可以给它传递零个或多个用逗号隔开的表达式。

此函数把你传递的表达式转换成一个字符串表达式，

并将结果写到标准输出。

 

例如：

print ("Hello Python")

标准屏幕上会产生以下结果：

 

读取键盘输入

Python提供了两个内置函数从标准输入读入一行文本，

默认的标准输入是键盘：

raw_input

input

注意：

python3.x系列不再有 raw_input 函数，

python 3.x中 input 和之前的 raw_input 等效

 

 

1. 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.com!\nvery good, thank you.\n");

 

# 关闭打开的文件

fo.close()

 

上述方法会创建foo.txt文件，并将收到的内容写入该文件，并最终关闭文件。

如果你打开这个文件，将看到以下内容:

www.freencre.com!

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模块提供了执行文件处理操作的方法，比如重命名和删除文件。

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

 

1. 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" )

 

1. 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顾名思义就是在内存中读写字符串。

 

1. 写入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!

 

 

1. 读取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，

1. 写入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。

 

1. 读取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:

 

1. SAX (simple API for XML )

python 标准库包含SAX解析器，

SAX用事件驱动模型，

通过在解析XML的过程中触发一个个的事件

并调用用户定义的回调函数来处理XML文件。

 

1. DOM(Document Object Model)

将XML数据在内存中解析成一个树，通过对树的操作来操作XML。

 

1. 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

1. SAX是一种基于事件驱动的API：

利用SAX解析XML文档需要：解析器和事件处理器。

 

解析器负责读取XML文档，并向事件处理器发送事件

事件处理器则负责对事件作出响应，对传递的XML数据进行处理。

 

使用的场景：

1、对大型文件进行处理；

2、只需要文件的部分内容，或者只需从文件中得到特定信息。

3、想建立自己的对象模型的时候。

 

1. 在python中使用sax方式处理xml：

要先引入xml.sax中的parse函数，

还有xml.sax.handler中的ContentHandler。

 

1. 调用时机：

从行开始，遇到标签之前，存在字符，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' : 'http://www.freencre.com'

}

 

json_str = json.dumps(data)

print ("Python 原始数据：", repr(data))

print ("JSON 对象：", json_str)

 

执行以上代码输出结果为：

Python 原始数据： {'no': 1, 'name': 'IT培训，永久免费', 'url': 'http://www.freencre.com'}

JSON 对象： {"no": 1, "name": "IT\u57f9\u8bad\uff0c\u6c38\u4e45\u514d\u8d39", "url": "http://www.freencre.com"}

通过输出的结果可以看出，

简单类型通过编码后跟其原始的repr()输出结果非常相似。

 

 

JSON编码的字符串转为Python数据结构

可以将一个JSON编码的字符串转换回一个Python数据结构：

 

#!/usr/bin/python3

import json

 

# Python 字典类型转换为 JSON 对象

data1 = {

    'no' : 1,

    'name' : ' IT培训，永久免费',

    'url' : 'http://www.freencre.com'

}

 

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': 'http://www.freencre.com'}

JSON 对象： {"no": 1, "name": " IT\u57f9\u8bad\uff0c\u6c38\u4e45\u514d\u8d39", "url": "http://www.freencre.com"}

data2['name']:   IT培训，永久免费

data2['url']:  http://www.freencre.com

 

 

 

序列化

Python序列化和反序列化

通过将对象序列化可以将其存储在变量或者文件中，

可以保存当时对象的状态，实现其生命周期的延长。

并且需要时可以再次将这个对象读取出来。

Python中有几个常用模块可实现这一功能。

 

pickle模块

1. 存储在变量中

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)

 

1. 读取数据

数据以字节保存在了byte_data变量中，

需要再次使用的时候使用loads函数就行了。

 

obj = pickle.loads(byte_data)

print(obj)

 

存储在文件中

也可以存在文件中，使得对象持久化。

使用的是dump和load函数，注意和上面的区别，少了s。

由于pickle写入的是二进制数据，

所以打开方式需要以wb和rb的模式。

 

1. 文件方式序列化

with open('abc.pkl', 'wb') as f:

    dic = {'age': 23, 'job': 'student'}

pickle.dump(dic, f)

 

1. 文件方式反序列化

with open('abc.pkl', 'rb') as f:

    aa = pickle.load(f)

    print(aa)

    print(type(aa))  # <class 'dict'>

 

json模块

pickle可以很方便地序列化所有对象。

不过json作为更为标准的格式，

具有更好的可读性（pickle是二进制数据）和跨平台性。

 

json使用的四个函数名和pickle一致。

 

1. 序列化为字符串

dic = {'age': 23, 'job': 'student'}

dic_str = json.dumps(dic)

print(type(dic_str), dic_str)

# out: <class 'str'> {"age": 23, "job": "student"}

 

1. 反序列化为对象

dic_obj = json.loads(dic_str)

print(type(dic_obj), dic_obj)

# out: <class 'dict'> {'age': 23, 'job': 'student'}

可以看到，

dumps函数将对象转换成了字符串。

loads函数又将其恢复成字典。

 

1. 存储为json文件

dic = {'age': 23, 'job': 'student'}

with open('abc.json', 'w', encoding='utf-8') as f:

    json.dump(dic, f)

 

1. 从json文件中恢复出python对象

with open('abc.json', encoding='utf-8') as f:

    obj = json.load(f)

    print(obj)