Python学习笔记（十一）：常用标准库概括
- 一、读写文件
- 1. file 对象
- 2. with 语句
- 3. fileinput 模块常见函数
- 4. pandas 模块处理文件
- 二、sys 模块常见用法
- 三、os 模块常见用法
- 四、日期和时间
- 1. time
- 2. calendar
- 五、正则表达式
一、读写文件
1. file 对象
open() 方法用于打开一个文件，并返回 file 对象。在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。使用 open() 方法一定要保证关闭文件对象，即调用 close() 方法。语法如下：
open(name[, mode [, buffering]] )
file: 必需，文件路径（相对或者绝对路径）。
mode: 可选，文件打开模式
buffering: 设置缓冲，如果是 0 或 False，I/O（输入/输出）就是无缓冲的，即所有读写操作都是针对硬盘；如果是 1 或 True，I/O 就是就是有缓冲的，即使用内存来代替硬盘，让程序更快，只有使用 flush 或 close 时才会更新硬盘上的数据。
mode常用值如下：
| 模式 | 描述 |
|---|---|
| r | 以只读方式打开文件，文件的指针将会放在文件的开头，默认。 |
| w | 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
| a | 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| x | 写模式，新建一个文件，如果该文件已存在则会报错。 |
| b | 二进制模式（可添加到其他模式中使用，如：rb表示以二进制格式打开一个文件用于只读，文件指针将会放在文件的开头）。 |
| + | 读／写模式（可添加到其他模式中使用，如：r+表示打开一个文件用于读写，文件指针将会放在文件的开头）。 |
'''
file.read([size])
从文件读取指定的字节数，如果未给定或为负则读取所有
file.readline([size])
读取整行，包括 "\n" 字符
file.readlines([sizeint])
读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区
file.write(str)
将字符串写入文件，返回的是写入的字符长度
file.writelines(sequence)
向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符
file.close()
关闭文件，关闭后文件不能再进行读写操作
file.name
返回文件名称
file.flush()
刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入
file.isatty()
如果文件连接到一个终端设备返回 True，否则返回 False
'''
f = open('demo.txt', 'w')
f.write('Hello, ')
f.write('World!\n')
f.writelines(('Hello, ', 'Python!'))
f.name # 'demo.txt'
f.close()
with open('demo.txt') as f:
f.read(7) # 'Hello, '
f.read() # 'World!\nHello, Python!'
f.read() # ''
with open('demo.txt') as f:
f.readline() # 'Hello, World!\n'
f.readline() # 'Hello, Python!'
f.readline() # ''
with open('demo.txt') as f:
f.readlines() # ['Hello, World!\n', 'Hello, Python!']
f.readlines() # []
2. with 语句
上下文管理器是一种支持 __enter__ 和 __exit__ 方法的对象，处理代码块运行时上下文的入口以及退出。with 语句允许使用上下文管理器处理文件，其 __enter__ 方法返回文件对象本身，__exit__ 方法关闭文件。语法如下：
with function() as fun:
do_something(fun)
上例，with 会执行 function 函数并将其赋值到变量 fun 上，紧跟 with 后面的 function() 语句被求值后，返回对象的 __enter__ 方法被调用，这个方法的返回值将被赋值给 fun。当 with 后面的代码块全部被执行完之后，将调用前面返回对象的 __exit__ 方法。
'''
object.__enter__(self)
输入与此对象相关的运行时上下文。如果存在的话，with语句将绑定该方法的返回值到该语句的as子句中指定的目标。
object.__exit__(self, exc_type, exc_value, traceback)
退出与此对象相关的运行时上下文。参数描述导致上下文退出的异常。如果该上下文退出时没有异常，三个参数都将为None。如果提供了一个异常，并且该方法希望抑制该异常（即防止它被传播），它应该返回一个真值。否则，在退出此方法后，异常将被正常处理。注意__exit__()方法不应该重新抛出传递进去的异常；这是调用者的责任。
'''
# 自己构造一个用于读写文件的上下文管理器
class File(object):
def __init__(self, name, mode):
self.file = open(name, mode)
def __enter__(self):
return self.file
def __exit__(self, type, value, traceback):
self.file.close()
with File('file1.txt', 'w') as file:
file.write('Hello, World!')
# 使用 Python 内置的写法
with open('file2.txt', 'w') as file:
file.write('Hello, Python!')
3. fileinput 模块常见函数
fileinput 模块让你能够轻松地遍历文本文件地所有行，即将多个文件作为输入，遍历文件的每一行。
'''
fileinput.input (files = None, inplace = False, backup = '')
files -- 文件的路径列表，如：['file1.txt','file2.txt',...]
inplace -- 是否原地修改文件内容，默认为不
backup -- 在进行原地修改（inplace = True）的时候，可选的 backup 参数将文件名扩展备份到原始文件创建的备份文件中
遍历多个输入流中的行
fileinput.filename()
返回当前正在处理的文件名
fileinput.lineno()
返回累计处理过的文件的行数
fileinput.filelineno()
返回当前文件的行数
fileinput.isfirstline()
判断当前行是否是文件的第一行，是返回 True，否则返回 False
fileinput.isstdin()
判断最后一行是否来自 sys.stdin，是返回 True，否则返回 False
fileinput.nextfile()
关闭当前文件，移动到下一个文件
fileinput.close()
关闭整个文件链，结束迭代
'''
4. pandas 模块处理文件
全部用法可参照文档：http://pandas.pydata.org/pandas-docs/stable/index.html
| Format Type | Data Description | Reader | Writer |
|---|---|---|---|
| text | CSV | read_csv | to_csv |
| text | JSON | read_json | to_json |
| text | HTML | read_html | to_html |
| text | Local clipboard | read_clipboard | to_clipboard |
| binary | MS Excel | read_excel | to_excel |
| binary | HDF5 Format | read_hdf | to_hdf |
| binary | Feather Format | read_feather | to_feather |
| binary | Parquet Format | read_parquet | to_parquet |
| binary | Msgpack | read_msgpack | to_msgpack |
| binary | Stata | read_stata | to_stata |
| binary | SAS | read_sas | |
| binary | Python Pickle Format | read_pickle | to_pickle |
| SQL | SQL | read_sql | to_sql |
| SQL | Google Big Query | read_gbq | to_gbq |
二、sys 模块常见用法
全部用法可参照文档：https://yiyibooks.cn/yy/python_278/library/sys.html
sys模块负责程序与Python解释器的交互，提供了一系列的函数和变量，用于操控python运行时的环境。
'''
sys.argv 命令行参数，包括脚本名称
sys.exit([arg]) 退出当前的程序，可选参数为给定的返回值或者错误信息
sys.modules 映射模块名字到载入模块的字典
sys.path 查找模块所在的目录的目录名列表
sys.stdin 标准输入流 -- 一个类文件（file-like）对象
sys.stdout 标准输出流 -- 一个类文件（file-like）对象
sys.stderr 标准错误流 -- 一个类文件（file-like）对象
'''
三、os 模块常见用法
全部用法可参照文档：https://yiyibooks.cn/yy/python_278/library/sys.html
os模块负责程序与操作系统的交互，提供了访问操作系统底层的接口。
'''
os.environ 对环境变量进行映射
os.system(command) 在子shell中执行操作系统命令
os.sep 路径中的分隔符
os.pathsep 分隔路径的分隔符
os.linesep 行分隔符（'\n','\r','\r\n'）
os.urandom(n) 返回n字节的加密强随机数据
'''
四、日期和时间
1. time
全部用法可参照文档：https://yiyibooks.cn/yy/python_278/library/time.html
time模块所包括的函数能够实现以下功能：获得当前时间、操作时间和日期、从字符串读取时间以及格式化时间为字符串。
'''
time.time()
返回当前时间戳（1970纪元后经过的浮点秒数）
time.localtime(sec)
接收时间戳转换成当地时间，如果 secs 没有提供或者为 None，则使用 time() 返回的当前时间
time.mktime(t)
与 localtime() 相反的操作，接受9个元素的时间元组 t 并返回时间戳（1970纪元后经过的浮点秒数），如果没有提供 t，则使用 localtime() 返回的当前时间
time.asctime(t)
将9个元素的时间元组 t 转换成一个24个字符的字符串，形式如下：'Sun Jun 20 23:21:05 1993'，如果没有提供 t，则使用 localtime() 返回的当前时间
time.ctime(sec)
作用相当于 asctime(localtime(secs))
time.sleep(t)
推迟调用线程的运行，可通过参数 t 指定秒数，表示进程挂起的时间
'''
import time
now = time.time()
now # 1548330509.2149482
localtime = time.localtime(now)
localtime # time.struct_time(tm_year=2019, tm_mon=1, tm_mday=24, tm_hour=19, tm_min=48, tm_sec=29, tm_wday=3, tm_yday=24, tm_isdst=0)
time.mktime(localtime) # 1548330509.0
time.asctime(localtime) # 'Thu Jan 24 19:48:29 2019'
time.ctime(now) # 'Thu Jan 24 19:48:29 2019'
def testSleep():
print("Start :", time.ctime())
time.sleep(5)
print("End :", time.ctime())
testSleep()
# Start : Thu Jan 24 19:48:29 2019
# End : Thu Jan 24 19:48:34 2019
2. calendar
'''
calendar.calendar(year, w=2, l=1, c=6)
返回一个多行字符串格式的 year 年年历，3个月一行，间隔距离为c，每日宽度间隔为 w 字符，l 是每星期行数
calendar.month(year, month, w=2, l=1)
返回一个多行字符串格式的 year 年 month 月日历，两行标题，一周一行，每日宽度间隔为 w 字符，l 是每星期的行数
calendar.firstweekday()
返回当前每周起始日期的设置。默认情况下，首次载入 calendar 模块时返回0，即星期一。
calendar.weekday(year, month, day)
返回给定日期为星期几，0（星期一）到 6（星期日），其中 month 为 1（一月） 到 12（12月）
calendar.isleap(year)
year 是闰年返回 True，否则为 False
calendar.leapdays(y1, y2)
返回在 Y1，Y2 两年之间的闰年总数
calendar.monthcalendar(year, month)
返回一个整数的单层嵌套列表，每个子列表装载代表一个星期的整数。year 年 month 月外的日期都设为0；范围内的日子都由该月第几日表示，从1开始
calendar.monthrange(year, month)
返回两个整数，第一个表示该月的第一天是星期几，从 0（星期一）到 6（星期日）；第二个整数是该月的天数
calendar.setfirstweekday(weekday)
设置每周的起始日为星期几，参数范围从 0（星期一）到 6（星期日）
'''
import calendar
calendar.calendar(2019)
"""
输出如下：
' 2019\n
\n
January February March\n
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su\n
1 2 3 4 5 6 1 2 3 1 2 3\n
7 8 9 10 11 12 13 4 5 6 7 8 9 10 4 5 6 7 8 9 10\n
14 15 16 17 18 19 20 11 12 13 14 15 16 17 11 12 13 14 15 16 17\n
21 22 23 24 25 26 27 18 19 20 21 22 23 24 18 19 20 21 22 23 24\n
28 29 30 31 25 26 27 28 25 26 27 28 29 30 31\n
\n
April May June\n
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su\n
1 2 3 4 5 6 7 1 2 3 4 5 1 2\n
8 9 10 11 12 13 14 6 7 8 9 10 11 12 3 4 5 6 7 8 9\n
15 16 17 18 19 20 21 13 14 15 16 17 18 19 10 11 12 13 14 15 16\n
22 23 24 25 26 27 28 20 21 22 23 24 25 26 17 18 19 20 21 22 23\n
29 30 27 28 29 30 31 24 25 26 27 28 29 30\n
\n
July August September\n
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su\n
1 2 3 4 5 6 7 1 2 3 4 1\n
8 9 10 11 12 13 14 5 6 7 8 9 10 11 2 3 4 5 6 7 8\n
15 16 17 18 19 20 21 12 13 14 15 16 17 18 9 10 11 12 13 14 15\n
22 23 24 25 26 27 28 19 20 21 22 23 24 25 16 17 18 19 20 21 22\n
29 30 31 26 27 28 29 30 31 23 24 25 26 27 28 29\n
30\n
\n
October November December\n
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su\n
1 2 3 4 5 6 1 2 3 1\n
7 8 9 10 11 12 13 4 5 6 7 8 9 10 2 3 4 5 6 7 8\n
14 15 16 17 18 19 20 11 12 13 14 15 16 17 9 10 11 12 13 14 15\n
21 22 23 24 25 26 27 18 19 20 21 22 23 24 16 17 18 19 20 21 22\n
28 29 30 31 25 26 27 28 29 30 23 24 25 26 27 28 29\n
30 31\n'
"""
calendar.month(2019, 1)
"""
输出如下：
' January 2019\n
Mo Tu We Th Fr Sa Su\n
1 2 3 4 5 6\n
7 8 9 10 11 12 13\n
14 15 16 17 18 19 20\n
21 22 23 24 25 26 27\n
28 29 30 31\n'
"""
calendar.firstweekday() # 0
calendar.weekday(2019, 1, 1) # 0
calendar.isleap(2019) # False
calendar.leapdays(2016, 2019) # 1
calendar.monthcalendar(2019, 1) # [[0, 1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12, 13], [14, 15, 16, 17, 18, 19, 20], [21, 22, 23, 24, 25, 26, 27], [28, 29, 30, 31, 0, 0, 0]]
calendar.monthrange(2019, 1) # (1, 31)
calendar.setfirstweekday(6)
calendar.month(2019, 1)
"""
设置每周的起始日为星期日，得到的输出如下：
' January 2019\n
Su Mo Tu We Th Fr Sa\n
1 2 3 4 5\n
6 7 8 9 10 11 12\n
13 14 15 16 17 18 19\n
20 21 22 23 24 25 26\n
27 28 29 30 31\n'
"""
五、正则表达式
全部用法可参照文档：https://yiyibooks.cn/yy/python_278/library/re.html
正则表达式（简称RE）确定一组匹配它的字符串；此模块中的函数让你检查一个特定的字符串是否匹配给定的正则表达式（或给定的正则表达式是否匹配特定的字符串，这可归结为同一件事）。
正则表达式修饰符（可选标志）如下：
| 修饰符 | 描述 |
|---|---|
| re.I | 使匹配对大小写不敏感 |
| re.M | 多行匹配，影响 ^ 和 $ |
| re.S | 使 . 匹配包括换行在内的所有字符 |
正则表达式模式如下：
| 模式 | 描述 |
|---|---|
| ^ | 匹配字符串的开头 |
| $ | 匹配字符串的末尾 |
| . | 匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符 |
| […] | 用来表示一组字符,单独列出：[amk] 匹配 ‘a’，‘m’或’k’ |
| [^…] | 不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符 |
| re* | 匹配0个或多个的 re 表达式 |
| re+ | 匹配1个或多个的 re 表达式 |
| re? | 匹配0个或1个由 re 表达式定义的片段 |
| re { n } | 精确匹配 n 个 re 表达式。例如， o{2} 不能匹配 “Bob” 中的 “o”，但是能匹配 “food” 中的两个 o |
| re { n, } | 匹配 n 个前面表达式。例如， o{2,} 不能匹配"Bob"中的"o"，但能匹配 "foooood"中的所有 o。“o{1,}” 等价于 “o+”。“o{0,}” 则等价于 “o*” |
| re { n, m } | 匹配 n 到 m 次由 re 表达式定义的片段 |
正则表达式实例如下：
| 实例 | 描述 |
|---|---|
| [0-9] | 匹配任何数字。类似于 [0123456789] |
| [a-z] | 匹配任何小写字母 |
| [A-Z] | 匹配任何大写字母 |
| [a-zA-Z0-9] | 匹配任何字母及数字 |
| [^aeiou] | 除了aeiou字母以外的所有字符 |
| [^0-9] | 匹配除了数字外的字符 |
| . | 匹配除 “\n” 之外的任何单个字符。要匹配包括 ‘\n’ 在内的任何字符，请使用 ‘[.\n]’ |
| \d | 匹配一个数字字符。等价于 [0-9] |
| \D | 匹配一个非数字字符。等价于 [^0-9] |
| \s | 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v] |
| \S | 匹配任何非空白字符。等价于 [^ \f\n\r\t\v] |
| \w | 匹配包括下划线的任何单词字符。等价于’[A-Za-z0-9_]’ |
| \W | 匹配任何非单词字符。等价于 ‘[^A-Za-z0-9_]’ |
'''
pattern -- 匹配的正则表达式
string -- 要匹配的字符串。
flags -- 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符（可选标志）
re.match(pattern, string, flags=0)
从字符串的起始位置匹配一个模式，若匹配成功返回一个匹配的对象，否则返回None
re.search(pattern, string, flags=0)
从字符串的起始位置匹配一个模式，若匹配成功返回第一个成功的匹配的对象，否则返回None
re.sub(pattern, repl, string, count=0, flags=0)
用 repl 替换字符串 string 中与 pattern 匹配成功的对象，其中 count 表示模式匹配后替换的最大次数，默认 0 表示替换所有的匹配
re.compile(pattern[, flags])
编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用
re.findall(string[, pos[, endpos]])
在字符串 string 中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表；pos 指定字符串的起始位置，默认为 0；endpos 指定字符串的结束位置，默认为字符串的长度
re.finditer(pattern, string, flags=0)
和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回
re.split(pattern, string[, maxsplit=0, flags=0])
按照能够匹配的子串将字符串分割后返回列表，其中 maxsplit 表示分隔次数，如 maxsplit=1 表示分隔一次，默认为 0，不限制次数
'''
import re
re.match('hello', 'hello python! hello world!') # <_sre.SRE_Match object; span=(0, 5), match='hello'>
re.match('python', 'hello python! hello world!') # None
re.search('hello', 'hello python! hello world!') # <_sre.SRE_Match object; span=(0, 5), match='hello'>
re.search('python', 'hello python! hello world!') # <_sre.SRE_Match object; span=(6, 12), match='python'>
re.sub(r'\D', "", '100-86-100-86-test', 3) # '1008610086-test'
pattern = re.compile(r'\d+') # 用于匹配至少一个数字
pattern.match('one12two24three56four') # 查找头部，没有匹配，返回 None
pattern.match('one12two24three56four', 3) # 从'1'的位置开始匹配，正好匹配：<_sre.SRE_Match object; span=(3, 5), match='12'>
pattern.findall('one12two24three56four') # ['12', '24', '56']
it = re.finditer(pattern, 'one12two24three56four')
for match in it:
print (match.group())
# 12
# 24
# 56
re.split('\W+', 'hello world! hello python!') # ['hello', 'world', 'hello', 'python', '']
以上全部内容参考书籍如下：
Magnus Lie Hetland《Python基础教程（第2版）》