1. I/O 编程
I/O指Input/Output；
Input Stream 从外面（磁盘、网络）流进内存；
Output Stream 从内存流到外面；
同步 I/O CPU 等待I/O完成，程序暂停后续执行；
异步 I/O CPU 不等待I/O完成，先做其他事，通过回调或轮询处理I/O后续；
文件读写
在磁盘上读写文件的功能都是有操作系统提供的，现代操作系统不允许普通程序直接操作磁盘；
文件流操作方法
| 方法 | 说明 |
|---|---|
| open() | 以指定模式打开文件对象，参数为文件名和模式标示符，可选参数encoding(编码) errors(编码错误处理方式) |
| read() | 一次读取文件所有内容，返回str对象 |
| read(size) | 每次读取size个字节的内容 |
| readline() | 每次读取一行内容 |
| readlines() | 一次读取所有内容，并返回以行分割的list |
| write() | 将要写入的内容写入内存缓存，当close 被调用时真正将内容写出 |
| close() | 关闭文件，关闭前将内存缓存中的内容全部写出 |
文件对象模式
| 字符 | 含义 |
|---|---|
r |
读取（默认） |
w |
写入，先 truncate 文件 |
x |
独占创建，如果文件已经存在则失败 |
a |
写入，如果文件已经存在则追加到文件末尾 |
b |
二进制模型 |
t |
文字模式（默认） |
+ |
更新（读写） |
读文件
with open('/Users/aurelius/test.txt', 'r') as f:
print(f.read())
with语句可保证open的文件最终会被close，同样的功能可以通过try ... finally语句在finally中执行close实现；
写文件
with open('/User/aurelius/test.txt', 'w') as f:
f.write('hello, world.')
StringIO 和 BytesIO
StringIO
在内存中读写str，和读写文件具有一致的接口；
from io import StringIO
# InputStream
f = StringIO()
f.write('hello')
# 读取写入的 str
f.getvalue()
# OutputStream
f = StringIO('hello, 中国')
f.read()
BytesIO
在内存中读写bytes
from io import BytesIO
# InputStream
f = BytesIO()
f.write('中文'.encode('utf-8'))
print(f.getvalue())
# OutputStream
f = BytesIO(b'\xe4\xb8\xad\xe6\x96\x87')
print(f.read().decode('utf-8'))
操作文件和目录
Python 内置的os模块可以直接调用系统提供的接口函数操作文件和目录；
>>> import os
>>> os.name
nt
环境变量
os.environ # 全部环境变量 (Class<Environ>)
os.environ.get('key', 'default') # 指定的环境变量，default 可选
操作文件和目录
| 函数 | 作用 |
|---|---|
| os.path.abspath(‘.’) | 当前路径的绝对路径 |
| os.path.join(r’d:\a’, ‘b’) | 把路径 2（b）拼接到路径 1（d:\a）上，路径 2 若为绝对路径，直接返回路径 2 |
| os.mkdir(r’d:\test’) | 创建一个目录 |
| os.mkdir(r’d:\test’) | 删除一个目录 |
| os.path.split(r’d:\test\file.txt’) | 拆分成最后级别目录和文件名 |
| os.path.splitext(r’d:\test\file.txt’) | 拆分下文件扩展名 |
| os.rename(‘test.txt’, ‘text.py’) | 重命名文件 |
| os.remove(‘test.py’) | 删除文件 |
| os.listdir(‘.’) | 列举指定路径 |
| os.path.isdir(‘d:\test’) | 判断是否路径 |
| os.path.isfile(‘d:\test\test.txt’) | 判断是否文件 |
shutil模块对os功能做了补充，其copyfile()提供文件复制功能；
序列化
把变量从内存中变成可存储或传输的过程称为序列化pickling，把序列化对象重新读到内存里称为反序列化unpickling；
Pickle
- dumps/dump
>>> import pickle
>>> d = dict(name='中国人', age=18, score=99)
# pickle.dumps 把任意对象序列化成 bytes
>>> pickle.dumps(d)
b'\x80\x04\x95*\x00\x00\x00\x00\x00\x00\x00}\x94(\x8c\x04name\x94\x8c\t\xe4\xb8\xad\xe5\x9b\xbd\xe4\xba\xba\x94\x8c\x03age\x94K\x12\x8c\x05score\x94Kcu.'
# pickle.dump 直接把对象序列化后写入 file-like Ojbect
>>> with open('dump.txt', 'wb') as w:
... pickle.dump(d, w)
- loads/load
>>> with open('dump.txt', 'rb') as r:
... d = pickle.load(r)
...
>>> d
{
'name': 'Aurelius', 'age': 18, 'score': 99}
pickle反序列化得到的变量与原来的变量完全无关，只是值相同而已；
pickle序列化只适用于 Python，且不同版本彼此不兼容；
JSON
序列化的一种标准格式，适用于不同编程语言之间传递，标准编码使用 UTF-8；
- JSON 类型关系
| JSON 类型 | Python 类型 |
|---|---|
| {} | dict |
| [] | list |
| string | str |
| int/float | int/float |
| true/false | True/False |
| null | None |
>>> import json
>>> d = dict(name='Aurelius', age=18, score=99)
>>> json_str = json.dumps(d)
>>> json_str
'{"name": "Aurelius", "age": 18, "score": 99}'
>>> json.loads(json_str)
{
'name': 'Aurelius', 'age': 18, 'score': 99}
dumps/dump的ensure_ascii参数可以决定是否统一将返回的str对象编码为ascii字符；
JSON 进阶
自定义类的对象不能直接序列化，需要实现dumps/dump的default参数对应的方法，将该对象转化成dict对象；
json.dumps(o, default=object2dict)
通常class都有__dict__属性，存储着实例的变量（定义了__solts__除外），因此可以直接如此调用；
json.dumps(o, default=lambda o: o.__dict__)
loads/load在反序列化自定义类型时也需传入object_hook相应方法，将dict对象转化为自定义类型的对象；
json.loads(json_str, object_hook=dict2object)
2. 正则表达式
用一种描述性的语言给字符串定义一个规则，用这种规则匹配字符串；
| 描述符 | 作用 | 示例 |
|---|---|---|
| \d | 匹配数字 | ‘00\d’ 匹配 ‘007’ |
| \w | 字母或数字 | ‘\w\w\d’ 匹配 ‘py3’ |
| . | 任意字符 | ‘py.’ 匹配 ‘pyc’、‘py!’ |
| * | 人一个字符串（包括 0 个） | |
| + | 至少 1 个字符 | |
| ? | 0 个或 1 个字符 | |
| {n} | n 个字符 | ‘\d{3}’ 匹配 ‘010’ |
| {n,m} | n ~ m 个字符 | ‘\d{3,8}’ 匹配 ‘1234567’ |
| \ | 转义字符 | ‘\d{3}-\d{3,8}’ 匹配 ‘010-12345’ |
| \s | 空格、空位符 |
进阶
| 描述符 | 作用 | 示例 |
|---|---|---|
| [] | 表示范围 | ‘[0-9a-zA-Z_]’ 匹配任意一个数字、字母或下划线 |
| A|B | 匹配 A 或 B | |
| ^ | 行的开头 | ‘^\d’ 表示以数字开头 |
| $ | 行的结束 | ‘\d$’ 表示以数字结束 |
re 模块
Python 字符串本身用\转义，正则表达式也用\转义，在拼写正则表达式时使用r前缀可以忽略掉 Python 本身字符串的转义；
match
>>> import re
>>> re.match(r'^\d{3}\-\d{3,8}$', '010-12345')
<re.Match object; span=(0, 9), match='010-12345'>
>>> re.match(r'^\d{3}\-\d{3,8}$', '010 12345')
>>>
当匹配成功时，返回一个 Match 对象，否则返回 None；
split
>>> re.split(r'\s+', 'a b c')
['a', 'b', 'c']
>>> re.split(r'[\s\,\;]+', 'a,b;; c d')
['a', 'b', 'c', 'd']
通过模式分割字符串，返回分割的数组；
group
>>> m = re.match(r'^(\d{3})-(\d{3,8})$', '010-12345')
>>> m
<re.Match object; span=(0, 9), match='010-12345'>
>>> m.group(2)
'12345'
>>> m.group(1)
'010'
>>> m.group(0)
'010-12345'
通过()提取分组子串，group(0)表示匹配的全部字符串，group(n)表示第 n 个子串；
贪婪匹配
匹配尽可能多的字符
>>> re.match(r'^(\d+)(0*)$', '102300').groups()
('102300', '')
>>> re.match(r'^(\d+)(0+)$', '102300').groups()
('10230', '0')
正则匹配默认是贪婪匹配，想要非贪婪匹配（尽可能少匹配），在\d+后加?；
>>> re.match(r'^(\d+?)(0*)$', '102300').groups()
('1023', '00')
编译
re模块执行步骤：
- 编译正则表达式，不合法则报错；
- 用编译后的正则表达式匹配字符串；
- 预编译
>>> import re
>>> re_telephone = re.compile(r'^(\d{3})-(\d{3,8})$')
>>> re_telephone.match('010-12345').groups()
('010', '12345')
>>> re_telephone.match('010-8086').groups()
('010', '8086')
匹配简单邮箱
def is_valid_email(addr):
if re.match(r'(^[a-zA-Z\.]+)\@(gmail|microsoft)\.com$', addr):
return True
else:
return False
匹配带名称邮箱，提取名称
def name_of_email(addr):
# 提取邮箱前缀
m = re.match(r'^([a-zA-Z\d\s\<\>]+)\@(voyager|example)\.(org|com)$', addr)
if not m:
return None
# 提取前缀中 <> 里面的名称，若不存在，则取全名
m = re.match(r'^\<([a-zA-Z\s]+)\>[\s]+[a-zA-Z\d]+|([a-zA-Z\d]+)$', m.group(1))
return m.group(1) if m and m.group(1) else m.group(2)
- 上一篇：「Python 基础」错误、调试与测试
- 下一篇：「Python 基础」进程与线程
PS：感谢每一位志同道合者的阅读，欢迎关注、评论、赞！