常用模块

time模块

time模块：支持三种不同形式的时间，不同形式的时间之间可以转换

1. 时间戳

时间戳：时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。

import time

print(time.time())

# 1566200008.393285

2. 格式化时间

格式化时间：格式化时间表示的普通的字符串格式的时间。

import time

print(time.strftime('%Y-%m-%d %X'))

# 2019-08-19 15:35:12

3. 结构化时间

结构化时间：结构化时间共有9个元素，分别为(年，月，日，时，分，秒，一年中的第几周，一年中的第几天，夏令时)

import time

print(time.localtime()) # 当地时间(中国时间)
print(time.gmtime()) # 标准时间

# time.struct_time(tm_year=2019, tm_mon=8, tm_mday=19, tm_hour=15, tm_min=36, tm_sec=51, tm_wday=0, tm_yday=231, tm_isdst=0)
# time.struct_time(tm_year=2019, tm_mon=8, tm_mday=19, tm_hour=7, tm_min=36, tm_sec=51, tm_wday=0, tm_yday=231, tm_isdst=0)

4. 不同格式时间的转换

4.1结构化时间转格式化时间

import time
print(time.strftime('%Y-%m-%d %X', time.localtime()))

4.2格式化时间转结构化时间

import time
print(time.strptime('2019-08-19 15:35:12', '%Y-%m-%d %X'))

4.3结构化时间转时间戳

import time
print(time.mktime(time.localtime()))

4.4时间戳转结构化时间

import time
print(time.localtime(time.time()))

5. 常用方法

import time

time.time()
time.sleep() # 睡眠

datetime模块

datetime模块：时间的修改

1. 返回当前时间

import datetime

print(datetime.datetime.now())

# 2019-08-19 15:48:19.687491

2. 修改时间

# 当前时间+3天,默认修改天数
import datetiem

print(datetime.datetime.now() + datetime.timedelta(3))

# 2019-08-22 15:50:31.875349

# 小时/分钟等其他的时间的修改,要加上对应的参数
print(datetime.datetime.now() + datetime.timedelta(hours=3))

random模块

1. 常用方法

1.1 random.random()

import random

# 打印一个大于0且小于1的
print(random.random())

# 0.49588168191947324

1.2 random.randint()

import random

# 打印一个大于等于0且小于等于3的整数
print(random.randint(0, 100))

# 60

1.3 random.shuffle()

import random

lt = [1, 2, 3, 4, 5]
# 打乱容器类元素的顺序
random.shuffle(lt)
print(lt)

# [1, 3, 2, 5, 4]

2. 了解

2.1 random.randrange()

import random

# 打印一个大于等于1且小于10的整数
print(random.randrange(1, 10))

# 1

2.2 random.uniform()

import random

# 打印一个大于1且小于3的小数
print(random.uniform(1, 3))

# 1.716845798263477

2.3 random.choice()

import random

# 打印列表内的任意一个元素
print(random.choice([1, 2, 3, 4, 'a', 'b']))

# 4

2.4 random.sample()

import random

# 打印列表内n个元素的组合，例如n=2
print(random.sample([1, 2, 3, 4, 'a', 'b'], 2))

# ['a', 'b']

os模块

os模块：与操作系统交互，可以操作文件

1. 常用方法

1.1 os.listdir()

import os

# 列出文件夹内所有的文件
res = os.listdir(r'F:studyPyCharmPyCharm文件')
print(res)

1.2 os.path.join()

import os

# 拼接地址
res = os.path.join(r'F:studyPyCharmPyCharm文件', 'os模块')
print(res)

1.3 os.path.dirname()

import os

# 获取上一级目录
print(os.path.dirname(__file__))

1.4 os.path.abspath()

import os

# 获取文件的绝对路径
print(os.path.abspath(__file__))

sys模块

sys模块：与python解释器交互

import sys

print(sys.argv) # 用cmd执行python文件的时候才能获取参数
print(sys.path) # 获取环境变量

json和pickle模块

序列化：将python的数据类型（字典最常用）变成json串
反序列化：将json串读成python的数据类型（字典最常用）

json模块

json模块：支持跨平台，常用的有字典和列表

import json

dic = {'a': 1}

# 在内存中转换
data = json.dumps(dic)
data = json.loads(data)

# 在文件中转换
with open() as fw:
    json.dump(dic, fw)
with open() as fr:
    data = json.load(fr)

pickle模块

pickle模块：可以序列化python中的所有对象，但是无法跨平台

import pickle

dic = {'a': 1}

# 在内存中转换
data = pickle.dumps(dic)
data = pickle.loads(data)

# 在文件中转换
with open() as fw:
    pickle.dump(dic, fw)
with open() as fr:
    data = pickle.load(fr)

hashlib和hmac模块

hashlib模块

hashlib模块：密码加密

import hashlib

m = hashlib.md5()
m.update(b'123456')
print(m.hexdigest())

特点：

变成固定的字符串
相同的字符串哈希后结果一样
叠加性

hmac模块

hmac模块：密码加密，可以加盐处理

import hmac

m = hmac.new(b'123')
m.update(b'123456')
print(m.hexdigest())

logging模块

logging模块：日志

import logging

# 1.生成logger对象
logger = logging.getLogger('xiaowu')

# 2.格式
formmater1 = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',datefmt='%Y-%m-%d %H:%M:%S %p',)
formmater2 = logging.Formatter('%(asctime)s :  %(message)s',datefmt='%Y-%m-%d %H:%M:%S %p',)
formmater3 = logging.Formatter('%(name)s %(message)s',)

# 3.打印对象
h1 = logging.FileHandler('h1.log')
h2 = logging.StreamHanfler

# 4.对象对象绑定格式
h1.setFormatter(formmater1)
h2.setFormatter(formmater2)

# 5.logger绑定打印对象
logger.addHandler(h1)
logger.addHandler(h2)

# 6.设置级别
logger.setLevel(30)

logger.debug('debug')
logger.info('info')
logger.warning('warning')
logger.error('error')
logger.critical('critical')

配置日志文件

import os
import logging.config

# 定义三种日志输出格式 开始
standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' 
                  '[%(levelname)s][%(message)s]'  # 其中name为getLogger()指定的名字；lineno为调用日志输出函数的语句所在的代码行
simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'
# 定义日志输出格式 结束

logfile_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))  # log文件的目录，需要自定义文件路径 # atm
logfile_dir = os.path.join(logfile_dir, 'log')  # C:UsersoldboyDesktopatmlog

logfile_name = 'log.log'  # log文件名，需要自定义路径名

# 如果不存在定义的日志目录就创建一个
if not os.path.isdir(logfile_dir):  # C:UsersoldboyDesktopatmlog
    os.mkdir(logfile_dir)

# log文件的全路径
logfile_path = os.path.join(logfile_dir, logfile_name)  # C:UsersoldboyDesktopatmloglog.log
# 定义日志路径 结束

# log配置字典
LOGGING_DIC = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'standard': {
            'format': standard_format
        },
        'simple': {
            'format': simple_format
        },
    },
    'filters': {},  # filter可以不定义
    'handlers': {
        # 打印到终端的日志
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',  # 打印到屏幕
            'formatter': 'simple'
        },
        # 打印到文件的日志,收集info及以上的日志
        'default': {
            'level': 'INFO',
            'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件
            'formatter': 'standard',
            'filename': logfile_path,  # 日志文件
            'maxBytes': 1024 * 1024 * 5,  # 日志大小 5M  (*****)
            'backupCount': 5,
            'encoding': 'utf-8',  # 日志文件的编码，再也不用担心中文log乱码了
        },
    },
    'loggers': {
        # logging.getLogger(__name__)拿到的logger配置。如果''设置为固定值logger1，则下次导入必须设置成logging.getLogger('logger1')
        '': {
            # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
            'handlers': ['default', 'console'],
            'level': 'DEBUG',
            'propagate': False,  # 向上（更高level的logger）传递
        },
    },
}



def load_my_logging_cfg():
    logging.config.dictConfig(LOGGING_DIC)  # 导入上面定义的logging配置
    logger = logging.getLogger(__name__)  # 生成一个log实例
    logger.info('It works!')  # 记录该文件的运行状态
    
    return logger


if __name__ == '__main__':
    load_my_logging_cfg()

numpy模块

numpy模块：专门进行数组(矩阵)的运算

一、创建numpy数组

numpy数组即numpy的ndarray对象，创建numpy数组就是把一个列表传入np.array()方法。

import numpy as np

# 创建一维的ndarray对象
print(np.array([1, 2, 3]))

# 创建二维的ndarray对象
print(np.array([[1, 2, 3], [4, 5, 6]]))

# 创建三维的ndarray对象
print(np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])
# 三维不要使用numpy模块，使用Tensorflow/pytorch模块

二、numpy数组的常用属性

属性	解释
T	数组的转置（对高维数组而言）
dtype	数组元素的数据类型
size	数组元素的个数
ndim	数组的维数
shape	数组的维度大小（以元组的形式）
astype	类型转换

import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr)

# [[1 2 3]
#  [4 5 6]]

print(arr.T)

# [[1 4]
#  [2 5]
#  [3 6]]

print(arr.dtype)

# int32

print(arr.size)

# 6

print(arr.ndim)

# 2

print(arr.shape)

# (2, 3)

arr = arr.astype(np.float32)
print(arr)

# [[1. 2. 3.]
#  [4. 5. 6.]]

三、切割numpy数组

import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr) #二维的numpy数组(一般就是二维) 

# [[1 2 3]
#  [4 5 6]]
print(arr[:, :])

# [[1 2 3]
#  [4 5 6]]

print(arr[0:1, :])

# [[1 2 3]]

print(arr[0:1], [0:1])

# [[1]]

print(arr[0, :])

# [1, 2, 3]

print(arr[0, 0], type(arr[0, 0]))

# 1 <class 'numpy.int32'>

print(arr[0, [0, 2]])

# [1 3]

四、numpy数组元素替换

import numpy as np

arr = np.array([1, 2, 3], [4, 5, 6])
print(arr)

# [[1 2 3]
#  [4 5 6]]

arr[0, :]
print(arr)

# [[0 0 0]
#  [4 5 6]]

arr[1, 1] = 1
print(arr)

# [[0 0 0]
#  [4 1 6]]

arr[arr < 3] = 3
print(arr)

# [[3 3 3]
#  [4 3 6]]

五、numpy数组的合并

import numpy as np

arr1 = np.array([[1, 2, 3], [4, 5, 6]]) # 可变数据类型
arr2 = np.array([[7, 8, 9], [10, 11, 12]])

print(np.hstack((arr1, arr2))) # 行合并

# [[ 1  2  3  7  8  9]
#  [ 4  5  6 10 11 12]]

print(np.vstack((arr1, arr2))) # 列合并

# [[ 1  2  3]
#  [ 4  5  6]
#  [ 7  8  9]
#  [10 11 12]]

print(np.concatenate((arr1, arr2))) # 默认列合并

# [[ 1  2  3]
#  [ 4  5  6]
#  [ 7  8  9]
#  [10 11 12]]

print(np.concatenate((arr1, arr2), axis=1)) # 1表示行;0表示列

# [[ 1  2  3  7  8  9]
#  [ 4  5  6 10 11 12]]

六、通过函数创建numpy数组

方法	详解
array()	将列表转换为数组，可选择显式指定dtype
arange()	range的numpy版，支持浮点数
linspace()	类似arange()，第三个参数为数组长度
zeros()	根据指定形状和dtype创建全0数组
ones()	根据指定形状和dtype创建全1数组
eye()	创建单位矩阵
empty()	创建一个元素全随机的数组
reshape()	重塑形状

七、numpy数组运算

运算符	说明
+	两个numpy数组对应元素相加
-	两个numpy数组对应元素相减
*	两个numpy数组对应元素相乘
/	两个numpy数组对应元素相除，如果都是整数则取商
%	两个numpy数组对应元素相除后取余数
**n	单个numpy数组每个元素都取n次方，如**2：每个元素都取平方

八、numpy数组运算函数

numpy数组函数	详解
np.sin(arr)	对numpy数组arr中每个元素取正弦，sin(x)sin(x)
np.cos(arr)	对numpy数组arr中每个元素取余弦，cos(x)cos(x)
np.tan(arr)	对numpy数组arr中每个元素取正切，tan(x)tan(x)
np.arcsin(arr)	对numpy数组arr中每个元素取反正弦，arcsin(x)arcsin(x)
np.arccos(arr)	对numpy数组arr中每个元素取反余弦，arccos(x)arccos(x)
np.arctan(arr)	对numpy数组arr中每个元素取反正切，arctan(x)arctan(x)
np.exp(arr)	对numpy数组arr中每个元素取指数函数，exex
np.sqrt(arr)	对numpy数组arr中每个元素开根号x−−√

九、numpy.random生成随机数

函数名称	函数功能	参数说明
rand(d0,d1,⋯,dnd0,d1,⋯,dn)	产生均匀分布的随机数	dndn为第n维数据的维度
randn(d0,d1,⋯,dnd0,d1,⋯,dn)	产生标准正态分布随机数	dndn为第n维数据的维度
randint(low[, high, size, dtype])	产生随机整数	low:最小值；high:最大值；size:数据个数
random_sample([size])	在[0,1)[0,1)内产生随机数	size为随机数的shape，可以为元祖或者列表
choice(a[, size])	从arr中随机选择指定数据	arr为1维数组；size为数组形状
uniform(low,high [,size])	给定形状产生随机数组	low为最小值；high为最大值，size为数组形状
shuffle(a)	与random.shuffle相同	a为指定数组

pandas模块

pandas模块：更多的是excel/csv文件处理，对numpy+xlrd模块做了一层封装

一、DataFrame(多维)属性

属性	详解
dtype是	查看数据类型
index	查看行序列或者索引
columns	查看各列的标签
values	查看数据框内的数据，也即不含表头索引的数据
describe	查看数据每一列的极值，均值，中位数，只可用于数值型数据
transpose	转置，也可用Ｔ来操作
sort_index	排序，可按行或列index排序输出
sort_values	按数据值来排序

二、DataFrame取值

通过columns取值
loc（通过行标签取值）
iloc（类似于numpy数组取值）
使用逻辑判断取值

三、DataFrame值替换

df.iloc[0:3, 0:2] = 0   # 把0赋值给0到3列，0到2行的值
df['c3'] > 10   # 判断c3列的值是否大于10，大于返回True，小于返回False

四、读取CSV文件

import pandas as pd
from io import StringIO
test_data = '''
5.1,,1.4,0.2
4.9,3.0,1.4,0.2
4.7,3.2,,0.2
7.0,3.2,4.7,1.4
6.4,3.2,4.5,1.5
6.9,3.1,4.9,
,,,
'''

test_data = StringIO(test_data)
df = pd.read_csv(test_data, header=None)
df.columns = ['c1', 'c2', 'c3', 'c4']
df

五、处理丢失数据

df.dropna(axis=0)   # axis=0删除有NaN值的行
df.dropna(axis=1)   # axis=1删除有NaN值的列
df.dropna(how='all')   # 删除全为NaN值的行或列
df.dropna(thresh=4)   # 删除没有四个值的行
df.dropna(subset=['c2'])   # 删除c2中有NaN值的行
df.fillna(value=10)   # 填充NaN值

六、合并数据

import pandas as pd
import numpy as np

df1 = pd.DataFrame(np.zeros((3, 4)))

df2 = pd.DataFrame(np.ones((3, 4)))

pd.concat((df1, df2), axis=0)   # axis=0合并列
pd.concat((df1, df2), axis=1)   # axis=1合并行
df1.append(df2)   # append只能合并列

七、导入导出数据

使用df=pd.read_excel(filename)读取数据，使用df.to_excel(filename)保存文件

7.1 读取文件导入数据

读取文件导入数据函数主要参数：

参数	详解
sep	指定分隔符，可用正则表达式如's+'
header=None	指定文件无行名
name	指定列名
index_col	指定某列作为索引
skip_row	指定跳过某些行
na_values	指定某些字符串表示缺失值
parse_dates	指定某些列是否被解析为日期，布尔值或列表

7.2 写入文件导出数据

写入文件函数的主要参数：

参数	详解
sep	分隔符
na_rep	指定缺失值转换的字符串，默认为空字符串
header=False	不保存列名
index=False	不保存行索引
cols	指定输出的列，传入列表

matplotlib模块

matplotlib模块：画图

条形图

import matplotlib.pyplot as plt # 默认支持英文,不支持中文
classes = ['3grade','4grade','5grade','6grade']
students = [50,60,55,67]

ind = range(len(classes))
plt.bar(ind,students,color='darkblue')
plt.xticks(ind,classes)
plt.show()

直方图

import matplotlib.pyplot as plt
import numpy as np

mu1, mu2, sigma = 50, 100, 10

x1 = mu1 + sigma * np.random.randn(100000)
x2 = mu2 + sigma * np.random.randn(100000)

fig = plt.figure()

ax1 = fig.add_subplot(1, 2, 1)
ax1.hist(x1, bins=50, color='yellow')
ax1.set_title('yellow',)

ax2 = fig.add_subplot(1, 2, 2)
ax2.hist(x2, bins=100, color='green')
ax2.set_title('green')

plt.show()

折线图

import matplotlib.pyplot as plt
import numpy as np

x1 = np.random.randn(1, 40).cumsum()
x2 = np.random.randn(1, 40).cumsum()
x3 = np.random.randn(1, 40).cumsum()
x4 = np.random.randn(1, 40).cumsum()

plt.plot(x1, marker='o', color='r', label='红线', linestyle='--')
plt.plot(x2, marker='*', color='y', label='黄线', linestyle='-.')
plt.plot(x3, marker='s', color='green', label='绿色', linestyle=':')
plt.plot(x4, marker='x', color='b', label='蓝色', linestyle='-')

plt.show()

散点图+直线图

import matplotlib.pyplot as plt
import numpy as np

font = FontProperties(fname='D:msyh.ttc')

x1 = np.arange(1,20,2)

y = x1**2

plt.scatter(x1,y,s=100)
plt.show()

re模块

re模块：从字符串里找特定的字符

一、re模块的基本语法（匹配规则）：

^：开头

import re

s = '人生苦短，python是岸'
print(re.findall('^人生', s))

# ['人生']

$：结尾

import re

s = '人生苦短，python是岸'
print(re.findall('是岸$', s))

# ['是岸']

[]：匹配[]中间的字符，只要单个字符

import re

s = 'abcdefabcd'
print(re.findall('[ef]', s))

# ['e', 'f']

[]+^联用：^对[]内的元素取反

import re

s = 'abcdefabcd'
print(re.findall('[^ef]', s))

# ['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd']

.：任意字符(除了 )

import re

s = 'abcdaaadef'
print(re.findall('a.', s))

# ['ab', 'aa', 'ad']

print(re.findall('a..', s))

# ['abc', 'aaa']

*：前面的字符0-无穷个

import re

s = 'abaacaaa'
print(re.findall('a*', s))

# ['a', '', 'aa', '', 'aaa', '']

+：前面的字符1-无穷个

import re

s = 'abaacaaa'
print(re.findall('a+', s))

# ['a', 'aa', 'aaa']

？：前面的字符0-1个

import re

s = 'abaacaaa'
print(re.findall('a?', s))

# ['a', '', 'a', 'a', '', 'a', 'a', 'a', '']

{m}：前面的字符m个

import re

s = 'abaacaaa'
print(re.findall('a{3}', s))

# ['aaa']

{n,m}：前面的字符n-m个

import re

s = 'abaacaaa'
print(re.findall('a{2,3}', s))

# ['aa', 'aaa']

d：数字

import re

s = 's1+s2=s3'
print(re.findall('d', s))

# ['1', '2', '3']

D：非数字

import re

s = 's1+s2=s3'
print(re.findall('D', s))

# ['s', '+', 's', '=', 's']

w：数字/字母/下划线

import re

s = 's 1 + s2
 = _ s3'
print(re.findall('w', s))

# ['s', '1', 's', '2', '_', 's', '3']

W：非数字/字母/下划线

import re

s = 's 1 + s2
 = _ s3'
print(re.findall('W', s))

# [' ', ' ', '+', ' ', '
', ' ', '=', ' ', ' ']

s：空格/ /

import re

s = 's 1 + s2
 = _ s3'
print(re.findall('s', s))

[' ', ' ', ' ', '
', ' ', ' ', ' ']

S：非空格/ /

import re

s = 's 1 + s2
 = _ s3'
print(re.findall('S', s))

['s', '1', '+', 's', '2', '=', '_', 's', '3']

：取消意义

import re

s = 'abad'
print(re.findall(r'a\d', s))

# ['a\d']

.*：贪婪模式(最大化),，找到继续找，让结果最大化

import re

s = 'abbcabc'
print(re.findall('a.*c', s))

# ['abbcabc']

.*?：非贪婪模式(最小化)，找到就马上停止

import re

s = 'abbcabc'
print(re.findall('a.*?c', s))

# ['abbc', 'abc']

()：只要括号内的

import re

s = 'abacad'
print(re.findall('a(.)', s))

# ['b', 'c', 'd']

A|B：A和B都要

import re

s = 'abacad'
print(re.findall('a|b', s))

# ['a', 'b', 'a', 'a']

二、re模块的方法

修饰符	描述
re.I	使匹配对大小写不敏感
re.L	做本地化识别（locale-aware）匹配
re.M	多行匹配，影响 ^ 和 $
re.S	使 . 匹配包括换行在内的所有字符
re.U	根据Unicode字符集解析字符。这个标志影响 w, W, , B.
re.X	该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

re.compile()：早期修饰符只能放在compile里面，现在可以直接加在findall()里面

re.findall()：打印所有值

import re

s = '123abc456
def789'
print(re.findall('d+', s))

# ['123', '456', '789']

re.mathch()：从开头开始搜索，搜索到了就有，没搜索到就放回None

import re

s = '123abc456
def789'
res = re.mathch('d+', s)
print(res.group()) # 拿到返回值并使用.group进行打印

# 123

re.search()：搜索第一个匹配结果，找到了就不找了

import re

s = '123abc456
def789'
res = re.search('d+', s)
print(res.group()) # 拿到返回值并使用.group进行打印

# 123

re.split()：按照匹配规则切割

import re

s = 'abc123def456ghi789jk'
print(re.split('d+', s))

# ['abc', 'def', 'ghi', 'jk']

re.sub()：按照匹配规则替换

import re

s = 'abc123def456ghi789jk'
print(re.sub('d+', '**', s))

# abc**def**ghi**jk

re.subn()：按照匹配规则替换，并计数

import re

s = 'abc123def456ghi789jk'
print(re.subn('d+', '**', s))

# ('abc**def**ghi**jk', 3)

分组：一个括号里的叫一个分组

import re

s = 'abc123edf456'
res = re.search('abc(?P<abc>d+)edf(?P<edf>d+)', s)
print(res.groupdict())

# {'abc': '123', 'edf': '456'}

typing模块

typing模块：提供了Generator(生成器类型),Iterable(可迭代类型),Iterator(迭代器类型)三种数据类型，限制函数

typing模块的作用

类型检查，防止运行时出现参数和返回值类型不符合。
作为开发文档附加说明，方便使用者调用时传入和返回参数类型。
该模块加入后并不会影响程序的运行，不会报正常的错误，只有提醒。

collections模块

collections模块：复杂的数据类型

1. 有名元组

可以用属性而不是索引来引用tuple的某个元素

from collections import namedtuple

point = namedtuple('point',['x', 'y'])
p = point(1, 2)
print(p.x)
print(p.y)

# 1
# 2

2. 默认字典

当key不存在的时候，会返回一个默认值

from collections import defaultdict

dic = defaultdict(lambda: 'NaN')
dic['a'] = 1
print(dic['a'])
print(dic['c'])

# 1
# NaN

3. 双端队列

可以追加或删除头部元素

from collections import depue

de = deque([1, 2, 3])
de.append(4)
print(de)
de.appendleft(0)
print(de)
de.popleft()
print(de)

# deque([1, 2, 3, 4])
# deque([0, 1, 2, 3, 4])
# deque([1, 2, 3, 4])

4. 计数器

可以统计字符出现的个数

from collections import Counter

s = 'programming'
c = Counter()
for i in s:
    c[i] += 1
print(c)

# Counter({'r': 2, 'g': 2, 'm': 2, 'p': 1, 'o': 1, 'a': 1, 'i': 1, 'n': 1})