Python 部分知识点总结（六）

一、argparse 模块

参数种类：

位置参数：参数放在那里，就要对应一个参数位置，例如：/etc 就是对应一个参数位置

选项参数：必须通过前面是 – 的短选项，或者 — 的长选项，然后后面的才算它的参数，当然短选项后面也可以没有参数
基本解析

import argparse

parser = argparse.ArgumentParser() # 获得一个参数解析器

args = parser.parse_args() # 分析参数

parser.print_help() # 打印帮助

argparse 不仅仅做了参数的定义和解析，还自动帮助生成了帮助信息，尤其是 usage，可以看到现在定义的参数是否是自己想要的
解析器的参数

          prog：程序的名字，缺省使用 sys.argv[0]

          add_help：自动为解析器增加 -h 和 –help 选项，默认为 True

          description：为程序功能添加描述

parser = argparse.ArgumentParser(prog=’ls’,description=’list directory contents’,add_help=True)
位置参数解析

ls 基本功能应该解决目录内容的打印

打印的时候应该指定目录路径，需要位置参数

parser = argparse.ArgumentParser(prog=’ls’,description=’list directory contents’,add_help=True)

parser.add_argument(‘path’)

args = parser.parse_args() # 分析参数

parser.print_help() # 打印帮助

运行结果：

usage：ls [-h] path

ls：error：the following arguments are required：path

即 -h 为帮助，可有可无；path 为位置参数，必须提供
传参

parse_args(args=None,namespace=None)：args 参数列表，一个可迭代对象，内部会把可迭代对象转换成 list，如果为 None 则使用命令行传入参数，非 None 则使用 args 参数的可迭代对象

import argparse

parser = argparse.ArgumentParser(prog=’ls’,description=’list directory contents’,add_help=True)

parser.add_argument(‘path’) # 位置参数

args = parser.parse_args((‘/etc’,)) # 分析参数，同时传入可迭代的参数

print(args) # 打印名词空间红收集的参数

parser.print_help() # 打印帮助

运行结果：

Namespace(path=’/etc’)

usage：ls [-h] path

list directory contents

positional arguments:

path

optional arguments：

-h,–help show this help message and exit

Namespace(path=’/etc’) 里面的 path 参数存储在了一个 Namespace 对象内的属性上，可以通过 Namespace 对象属性来访问，例如：args.path
非必须位置参数

有时候，ls 命令不输入任何路径的话就表示列出当前目录的文件列表

import argparse

parser = argparse.ArgumentParser(prog=’ls’,description=’list directory contents’,add_help=True)

parser.add_argument(‘path’,nargs=’?’,default=’.’,help=”path help”) # 位置参数

help：表示帮助文档中的这个参数的描述

nargs：表示这个参数接收结果参数，？表示可有可无，+ 表示至少一个，* 可以任意个，数字表示必须是指定数目个

default：表示如果不提供该参数，就使用这个值，一般和？ * 配合，因为它们都可以不提供位置参数，不提供就是用缺省值

二、序列化和反序列化

序列化（serialization）：将内存中对象存储下来，把它变成一个个字节 –> 二进制

反序列化（deserialization）：将文件的一个个字节恢复成内存中的对象 < — 二进制

持久化：序列化保存到文件就是持久化，可以将数据序列化后持久化，或者网络传输；也可以将从文件中或者网络接收到的字节序列反序列化
pickle 库：Python 中的序列化、反序列化模块

      dumps 对象序列化为 bytes 对象

      dump 对象序列化到文件对象，就是存入文件

      loads 从 bytes 对象反序列化

      load 对象反序列化，从文件读取数据
import pickle

filename = ‘test.txt’

d = {‘a’:1,’b’:’abc’,’c’:'[1,2,3]’}

l = list(‘123’)

i = 99

with open(filename,’wb’) as f:

    pickle.dump(d,f)

    pickle.dump(l,f)

    pickle.dump(i,f)

with open(filename,’rb’) as f:

    print(f.read(),f.seek(0))

    for _ in range(3):

        x = pickle.load(f)

        print(type(x),x)

class AA:

    tttt = ‘ABC’

    def show(self):

        print(‘abc’)

a1 = AA()

sr = pickle.dumps(a1)

print(sr)

a2 = pickle.loads(sr)

print(a2.tttt)

a2.show()

b’\x80\x03}q\x00(X\x01\x00\x00\x00bq\x01X\x03\x00\x00\x00abcq\x02X\x01\x00\x00\x00cq\x03X\x07\x00\x00\x00[1,2,3]q\x04X\x01\x00\x00\x00aq\x05K\x01u.\x80\x03]q\x00(X\x01\x00\x00\x001q\x01X\x01\x00\x00\x002q\x02X\x01\x00\x00\x003q\x03e.\x80\x03Kc.’ 0

<class ‘dict’> {‘b’: ‘abc’, ‘c’: ‘[1,2,3]’, ‘a’: 1}

<class ‘list’> [‘1’, ‘2’, ‘3’]

<class ‘int’> 99

b’\x80\x03c__main__\nAA\nq\x00)\x81q\x01.’

ABC

abc

上面的例子中，其实就保存了一个类名，因为所有的其他东西都是类定义的东西，是不变的，所以只序列化一个 AA 类名，反序列化的时候找到类就可以恢复一个对象
import pickle

class AAA:

def __init__(self):

self.tttt = ‘abc’

a1 = AAA()

ser = pickle.dumps(a1)

print(ser)

a2 = pickle.loads(ser)

print(a2,type(a2))

print(a2.tttt)

print(id(a1),id(a2))

b’\x80\x03c__main__\nAAA\nq\x00)\x81q\x01}q\x02X\x04\x00\x00\x00ttttq\x03X\x03\x00\x00\x00abcq\x04sb.’

<__main__.AAA object at 0x7f625c06a390> <class ‘__main__.AAA’>

abc

140060427461408 140060427461520

可以看出这次除了必须保存的AAA，还序列化了 tttt 和 abc，因为这是每一个对象自己的属性，每一个对象不一样的，所以这些数据需要序列化

序列化、反序列化必须保证使用同一套类的定义，否则会带来不可预料的结果
JSON（JavaScript Object Notation，JS 对象标记）是一种轻量级的数据交换格式，它基于 ECMAScript（w3c 制定的 JS 规范）的一个子集，采用完全独立于编程语言的文本格式来存储和表示数据
值：双引号引起来的字符串、数值、true 和 false、null、对象、数组，这些都是值

字符串：由双引号包围起来的任意字符的组合，可以有转义字符

数值：有正负、整数、浮点数

对象：无序的键值对的集合

          格式：{key1:value,….keyn:valuen}

          key 必须是一个字符串，需要双引号包围这个字符串

          value 可以是任意合法的值

数组：有序的值得集合，格式：[val1,….valn]
Python 支持少量内建数据类型到 Json 类型的转换

Python类型       Json类型

True                  true

False                  false

None                  null

str                      string

int                      integer

float                     float

list                      array

dict                      object

dumps              json编码

dump                 json编码并存入文件

loads                  json解码

load                  json解码，从文件读取数据

三、正则表达式

元字符

.       匹配出换行符外任意一个字符

[abc] 字符集合，只能表示一个字符位置，匹配所包含的任意一个字符

[^abc] 字符集合，只能表示一个字符位置，匹配除去集合内字符的任意一个字符

[a-z]    字符范围，是一个集合，表示一个字符位置，匹配所包含的任意一个字符

\b        匹配单词的边界

\B        不匹配单词的边界，如 t\B 包含 t 的单词但是不以 t 结尾的字符，write

\d          匹配 [0-9] 中任意一个数字

\D        匹配 [0-9] 中任意一个数字

\s       匹配1位空白字符，包括换行符、制表符、空格

\S        匹配一位非空白字符

\w        匹配[0-9a-zA-Z_]，包括中文的字

\W        匹配\w之外的字符
转义：具有特殊意义的符号，如果想使用它的本意，用反斜杠 \ 转义，\r 回车，\n 换行
重复

* 重复 0 次或多次

+ 重复至少 1 次

? 重复 0 次或 1 次

{n} 重复固定的 n 次

{n,} 重复至少 n 次

{n,m} 重复 n 到 m 次

x|y 匹配 x 或者 y

(pattern) 使用小括号指定一个子表达式，也叫分组

\数字            匹配对应的分组

(?:pattern)         如果仅仅为了改变优先级，就不需要捕获分组

(?P<name>exp)    分组捕获，但是可以通过 name 访问分组

(?=exp)                零宽度正预测先行断言，断言 exp 一定在匹配的右边出现

(?<=exp)         零宽度正回顾后发断言，断言 exp 一定出现在匹配的左边出现

(?!exp)                零宽度负预测先行断言，断言 exp 一定不会出现在右侧

(?<!exp)              零宽度负回顾后发断言，断言 exp 一定不能出现在左侧

(?#comment)       注释，如：f(?=oo)(?#这个后断言不捕获)
贪婪与非贪婪：默认是贪婪模式，即尽量多匹配更长的字符串，在重复的符号后面加上一个 ?，就会尽量的少匹配

*?           匹配任意次，但尽可能少重复

+?            匹配至少 1 次，但尽可能少重复

??              匹配 0 次或 1 次，但尽可能少重复

{n,}?       匹配至少 n 次，但尽可能少重复

{n,m} 匹配至少 n 次，至多 m 次，但尽可能少重复
引擎选项

IgnoreCase 匹配时忽略大小写，re.I

Singleline 单行模式，可以匹配所有字符，包括 \n，re.S

Multiline 多行模式，^行首，$行尾，re.M

ignorePatternWhitespace 忽略表达式中的空白字符，如果要使用空白字符，用转义，#可以做注释，re.X

单行模式就如同看穿了换行符，所有文本就是一个长长的只有一行的字符串，所有 ^ 就是这一行字符串的行首，$ 就是这一行的行尾

多行模式，无法看穿换行符，^ 和 $ 还是行首行尾的意思，只不过限于每一行
方法

编译：re.compile(pattern,flags=0)

       设定 flags，编译模式，返回正则表达式对象 regex

      pattern 就是正则表达式字符串，flags 是选项，正则表达式需要被编译，为了提高效率，这些编译后的结果被保存，下次使用同样的 pattern 的时候，就不需要再次编译

      re 的其它方法为了提高效率都调用了编译方法，就是为了提高提速

单词匹配：re.match(pattern,string,flag=0)

              regex.match(string[,pos[,endpos]])

              match 匹配从字符串的开头匹配，regex 对象 match方法可以重设定开始位置和结束位置，返回 match 对象，必须从开头开始，找到一个就不找了，找不到就返回 None

              re.search(pattern,string.flags=0)

                 regex.search(string[,pos[,endpos]])

              match 匹配从字符串的开头匹配，regex 对象 match 方法可以重设定开始位置和结束位置，返回 match 对象，找到第一个就不找了

              re.fullmatch(pattern,string.flags=0)

              regex.fullmatch(string[,pos[,endpos]])

                 整个字符串和正则表达式匹配，必须是完全匹配，多了少了都不行

全文搜索：re.findall(pattern,string,flags=0)

                 re.findall(string[,pos[,endpos]])

              对整个字符串，从左至右匹配，返回所有匹配项的列表

                 re.finditer(pattern,string,flags=0)

                 regex.finditer(string[,pos[,endpos]])

              对整个字符串，从左至右匹配，返回所有匹配项，返回迭代器

              注意每次迭代返回的是 match 对象

匹配替换：re.sub(pattern,replacement,string,count=0,flags=0)

              regex.sub(replacement,string,count=0)

              使用 pattern 对字符串 string 进行匹配，对匹配项使用 repl 替换

              replacement 可以是 string、bytes、function

              re.subn(pattern,replacement,string,count=0,flags=0)

              regex.subn(replacement,string,count=0)

              同 sub 返回一个元祖（new_string，number_of_subs_made）

分割字符串：re.split(pattern,string,maxsplit=0,flags=0)

                  字符串的分割函数太难用，不能指定多个字符进行分割

分组：使用小括号的 pattern 捕获的数据被放到了组 group 中

          match、search 函数可以返回 match 对象，findall 返回字符串列表，finditer 返回一个个 match 对象

          如果 pattern 中使用了分组，如果有匹配的结果，会在 match 对象中

                  1、使用 group(N) 方式返回对应分组，1-N 是对应的分组，0 返回整个匹配的字符串

                  2、如果使用了命名分组，可以使用 group(‘name’) 的方式取分组

                  3、也可以使用 groups() 返回所有组

                  4、使用 groupdict() 返回所有命名的分组