python中的关键字---7（re/序列化/Counter模块）

import re  正则

正则表达式
        # 元字符
            # w 数字字母下划线
            # W 非数字字母下划线
            # d 数字
            # D 非数字
            # s 空白符(空格制表符换行符)
            # S 非空白符
            # 	 制表符
            # 
 换行符
            #  单词的边界

            # . 除了换行符以外的所有

            # ^ 开始
            # $ 结尾
            # [..] 字符组
            # [^..] 非字符组
            # | 或(包含关系中,长的在前面)
            # () 分组(在或的两端,在添加量词的时候,findall的时候优先要显示的)
                # (123d)?
        # 量词
            # {n}
            # {n,}
            # {n,m}

            # ? 0,1
            # + 1,~
            # * 0,~

# 元字符 --> 一个字符匹配
# 元字符量词  --> 默认贪婪匹配
# 元字符量词? --> 惰性匹配/非贪婪模式



# 转义符  : r'正则'

import re    re模块
# re.findall('正则表达式','带匹配的字符')

# ret = re.match('d+','正则表达式','带匹配的字符')
# ret = re.search('^d+','正则表达式','带匹配的字符')
# print(ret)
# print(ret.group())

#            参数           返回值
# findall 正则 待匹配字符串  列表,所有符合的项
# search  正则 待匹配字符串  变量,.group取结果,只有一项结果
# match   正则 待匹配字符串  变量,.group取结果,默认在正则之前加上^

---

import json / pickle   序列化模块

import json
# 把其他的数据类型 -序列化(dumps)-> 字符串
# 字符串 -反序列化(loads)-> 把其他的数据类型
# ret = json.dumps(menu)     # 把其他的数据类型 -序列化(dumps)-> 字符串
# # print(ret)    # json格式的字符串
# # print(menu)   # dict
# with open('file','w',encoding='utf-8') as f:
#      f.write(ret)
# with open('file','r',encoding='utf-8') as f:
#      dic = f.read()
# print(dic)
# diccc = json.loads(dic)     # 字符串 -反序列化(loads)-> 把其他的数据类型
# print(diccc['k'])

# 数据类型 <-转换-> 字符串
# 1.存储在硬盘上 写的每一个字符必须是字符串/bytes数据类型
# 2.网络传输的时候 必须传递bytes/字符串数据类型
# menu = {'key':"value","k":['v']}
# ret = json.dumps(menu)
# dic = json.loads(ret)

# 优缺点:
     # 优: 所有的语言都通用
     # 缺: 能支持的数据类型少 :dict list str 数字

import pickle

# json  dumps/loads
# 字符串的json数据 = json.dumps(其他数据类型)
# 其他数据类型= json.loads(字符串的json数据)

# pickle dumps/loads  dump/load
# bytes的pickle数据 = pickle.dumps(其他数据类型)
# 其他数据类型= pickle.loads(bytes的pickle数据)
# pickle.dump(数据类型,文件句柄)  # 这个数据类型被写到文件里了
# pickle.load(文件句柄)  # 这个文件里的数据类型

import pickle
menu = {'key':"value","k":{'v',1,2}}
# ret = pickle.dumps(menu)
# print(type(ret),ret)
# dic = pickle.loads(ret)
# print(dic)
menu = {'key':"value","k":(1,2,3)}
# ret = pickle.dumps(menu)
# print(type(ret),ret)
# dic = pickle.loads(ret)
# print(dic)
menu = {'key':"value",1:'vvv'}
# ret = pickle.dumps(menu)
# print(type(ret),ret)
# dic = pickle.loads(ret)
# print(dic)

# 序列化模块总结 :
#     将基础数据类型存到文件中再读出来
#     将基础数据类型通过网络传给其他程序,再由其他程序读取并使用
    # json
        # 优点 : 所有语言通用
        # 缺点 : 支持的数据类型少
        # 方法和用法:
        # dump
            # dump(dict/list,文件句柄)   # 文件句柄一定是以写的形式打开的
        # load
            # dict/list = load(文件句柄) # 文件句柄一定是以读的形式打开的
        # dumps
            # str = dumps(基础数据类型)
        # loads
            # 基础数据类型 = loads(str)
    # pickle
        # 优点 : 支持python中几乎所有数据类型
                # load文件的时候,可以load多条数据,也可以dump多条数据
        # 缺点 : 只支持在python程序之间交换数据
        # dump(任意一个需要写到文件中的变量,文件句柄)  # 文件句柄,wb/ab形式打开
        # load(文件句柄)   # 文件句柄是以rb形式打开
            # pickle 的dump可以dump多次,load可以load多次
        # dumps
            # bytes = dumps(基础数据类型)
        # loads
            # 基础数据类型 = loads(bytes)

---

 

collections模块—— Counter
Counter目的是用来跟踪值出现的次数。它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value。
　　　　计数值可以是任意的Interger（包括0和负数）。Counter类和其他语言的bags或multisets很相似。
下面的代码说明了Counter类创建的四种方法：
Counter类的创建

>>> c = Counter()  # 创建一个空的Counter类
>>> c = Counter('gallahad')  # 从一个可iterable对象（list、tuple、dict、字符串等）创建
>>> c = Counter({'a': 4, 'b': 2})  # 从一个字典对象创建
>>> c = Counter(a=4, b=2)  # 从一组键值对创建

 

计数值的访问与缺失的键

当所访问的键不存在时，返回0，而不是KeyError；否则返回它的计数。

计数值的访问

>>> c = Counter("abcdefgab")
>>> c["a"]
2
>>> c["c"]
1
>>> c["h"]
0

计数器的更新（update和subtract）

可以使用一个iterable对象或者另一个Counter对象来更新键值。

计数器的更新包括增加和减少两种。其中，增加使用update()方法：

计数器的更新（update）

 

>>> c = Counter('which')
>>> c.update('witch')  # 使用另一个iterable对象更新
>>> c['h']
3
>>> d = Counter('watch')
>>> c.update(d)  # 使用另一个Counter对象更新
>>> c['h']
4

减少则使用subtract()方法：

计数器的更新（subtract）

>>> c = Counter('which')
>>> c.subtract('witch')  # 使用另一个iterable对象更新
>>> c['h']
1
>>> d = Counter('watch')
>>> c.subtract(d)  # 使用另一个Counter对象更新
>>> c['a']
-1
键的修改和删除

当计数值为0时，并不意味着元素被删除，删除元素应当使用del。 

键的删除

>>> c = Counter("abcdcba")
>>> c
Counter({'a': 2, 'c': 2, 'b': 2, 'd': 1})
>>> c["b"] = 0
>>> c
Counter({'a': 2, 'c': 2, 'd': 1, 'b': 0})
>>> del c["a"]
>>> c
Counter({'c': 2, 'b': 2, 'd': 1})
其他常用操作

下面是一些Counter类的常用操作，来源于Python官方文档

Counter类常用操作

sum(c.values())  # 所有计数的总数
c.clear()  # 重置Counter对象，注意不是删除
list(c)  # 将c中的键转为列表
set(c)  # 将c中的键转为set
dict(c)  # 将c中的键值对转为字典
c.items()  # 转为(elem, cnt)格式的列表
Counter(dict(list_of_pairs))  # 从(elem, cnt)格式的列表转换为Counter类对象
c.most_common()[:-n:-1]  # 取出计数最少的n个元素
c += Counter()  # 移除0和负值