time模块

import time

time模块的常用方法：

时间戳

从1970年1月1日0：00：00开始按秒计算

time.time()

格式化时间（显示当前时间）

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

%Y 年 -%m月- %d日 %X秒

datetime模块

import datetime

返回当前时间

print(datetime.datetime.now())

2019-8-19 15:05:30.000000

#当前时间
print(datetime.datetime.now())
#当前时间的加减
print(print(datetime.datetime.now() + datetime.timedelta(3)))

2019-8-19 15:05:30.000000

2019-8-22 15:05:30.000000

通过datetime.timedelta添加来达到当前日期的加减模式：

默认加减天数，hours加减小时，minutes加减分钟

random模块

import random

random模块方法

random方法：

#大于0且小于1的小数
print(random.random())
#想生成0且小于多少的小数只要在后面乘多少就好啦 
print(random.random()*10)

生成随机整数

#随机生成0到4之间的整数
random.randint(0,4)

os模块

import time

os模块常用方法

import os
#经常用的常用方法
res = os.listdir(r'G:\py')#列出该文件夹下的所有文件
res = os.path.join(r'G:\py','guapi.py')#拼接文件夹路径
#常用方法中的不常用方法
os.path
os.mkdir('m2') #创建一个叫m2的文件夹
os.rmdir('没') #删除一个叫m2的文件加

sys模块

import sys

#常用方法
sys.argv() 通过命令行返回参数
sys.path()返回python的环境变量路径

json模块

import json

#json常用方法
import json
#序列化
struct_data = {'name': 'json', 'age': 23, 'sex': 'male'}
with open('test.json','w') as fw:
    json.dump(struct_data,fw)
#反序列化
with open('test.json') as fr:
    date = json.load(fr)
    print(date)

json的用途：

在编写接口传递数据时，往往需要使用JSON对数据进行封装。python和json数据类型的转换，看作为编码与解码。

pickle模块

import pickle

pickle用途：

可以将python所有的数据类型进行序列化和反序列化，通过二进制进行保存

# 序列化(注意：pickle模块需要使用二进制存储，即'wb'模式存储)
with open('Pickle序列化对象.pkl', 'wb') as fw:
    pickle.dump(struct_data, fw)
# 反序列化
with open('Pickle序列化对象.pkl', 'rb') as fr:
    pickle = pickle.load(fr)
print(data)

hashlib模块

import hashlib

什么是hash：

用于密码的加密，是一种加密的方式

特点：1.传入的内容一样时，得到的hash值一样，用于密码校验

2.不能有hash值返解成内容，保证密码的安全性

3.无论多长，得到的hash长度时一致的

#hashlib模块的方法：
import hashlib
m=hashlib.md5()
m.update('hello'.encode('utf8'))
a=hashlib.md5()
a.update('hello'.encode('utf8'))
print(m.hexdigest())
print(a.hexdigest())

5d41402abc4b2a76b9719d911017c592 5d41402abc4b2a76b9719d911017c592

hmac模块

hamc模块

import hmac

hmac模块的使用方法

import hmac

h1=hmac.new(b'hash')
h1.update(b'hello')
h1.update(b'world')
print(h1.hexdigest())
h2 = hmac.new(b'hash')
h2.update(b'helloworld')
print(h2.hexdigest())

logging模块

import time

logging模块包含四种角色：logger、Filter、Formatter对象、Handler

logger：产生日志的对象
Filter：过滤日志的对象
Formatter对象：可以定制不同的日志格式对象，然后绑定给不同的Handler对象使用，以此来控制不同的Handler的日志格式
Handler：接收日志然后控制打印到不同的地方，FileHandler用来打印到文件中，StreamHandler用来打印到终端

numpy模块

import numpy as np

numpy常用方法

import numpy as np
arr1 = np.array([[1,2,3],[4,5,6]])
print(arr1) #输出arr1的数组


print(arr1.T)#数组的转置
arr2 = np.array([[7,8,9],[10,11,12]])
print(arr1*arr2) #数组的算法

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

arr = np.hstack((arr1,arr2))
print(arr[:,:]) #取所有
# print(arr[:1,:])    #取第一行所有元素
# print(arr[:,:1])    #取第一列

通过函数生成numpy数组

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

arange生成

import numpy as np
print(np.arange(5))     #生成0-4的一维数组
print(np.arange(5),np.arange(5))    #生成0-4的二维数组

zeros()/noes()生成

import numpy as np
print(np.zeros((3,4)))  #生成一个3行4列全是0的二维数组
print(np.ones((3,4)))   #生成一个3行4列全是1的二维数组
print(np.ones((5,6))*5) #生成5行6列全是5的二维数组

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−−√

pandas模块

import numpy as np

常与numpy连用

import pandas as pd
import numpy as np

arr =np.array([1,2,3,4,np.nan]) 生成一个列表，np.nan表示空值
print(arr)
df=pd.Series(arr,index=['a','b','c','d','e'])   #根据索引创建表格
print(type(df))

pandas常用属性方法 dateframe属性

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

matplotlib模块

一、条形图

[0, 1, 2, 3]
student_amounts = [66, 55, 45, 70]

# 画布设置
fig = plt.figure()
# 1,1,1表示一张画布切割成1行1列共一张图的第1个；2,2,1表示一张画布切割成2行2列共4张图的第一个（左上角）
ax1 = fig.add_subplot(1, 1, 1)
ax1.bar(classes_index, student_amounts, align='center', color='darkblue')
ax1.xaxis.set_ticks_position('bottom')
ax1.yaxis.set_ticks_position('left')

plt.xticks(classes_index,
           classes,
           rotation=0,
           fontsize=13,
           fontproperties=font)
plt.xlabel('班级', fontproperties=font, fontsize=15)
plt.ylabel('学生人数', fontproperties=font, fontsize=15)
plt.title('班级-学生人数', fontproperties=font, fontsize=20)
# 保存图片，bbox_inches='tight'去掉图形四周的空白
# plt.savefig('classes_students.png?x-oss-process=style/watermark', dpi=400, bbox_inches='tight')
plt.show()

二、直方图

[59.00855949 43.16272141 48.77109774 ... 57.94645859 54.70312714
 58.94125528]
# 构造均值为100的符合正态分布的数据
x2 = mu2 + sigma * np.random.randn(10000)
print(x2)
[115.19915511  82.09208214 110.88092454 ...  95.0872103  104.21549068
 133.36025251]
fig = plt.figure()
ax1 = fig.add_subplot(121)
# bins=50表示每个变量的值分成50份，即会有50根柱子
ax1.hist(x1, bins=50, color='darkgreen')

ax2 = fig.add_subplot(122)
ax2.hist(x2, bins=50, color='orange')

fig.suptitle('两个正态分布', fontproperties=font, fontweight='bold', fontsize=15)
ax1.set_title('绿色的正态分布', fontproperties=font)
ax2.set_title('橙色的正态分布', fontproperties=font)
plt.show()

三、折线图

[ 1.62434536  1.01258895  0.4844172  -0.58855142  0.2768562  -2.02468249
 -0.27987073 -1.04107763 -0.72203853 -0.97140891  0.49069903 -1.56944168
 -1.89185888 -2.27591324 -1.1421438  -2.24203506 -2.41446327 -3.29232169
 -3.25010794 -2.66729273 -3.76791191 -2.6231882  -1.72159748 -1.21910314
 -0.31824719 -1.00197505 -1.12486527 -2.06063471 -2.32852279 -1.79816732
 -2.48982807 -2.8865816  -3.5737543  -4.41895994 -5.09020607 -5.10287067
 -6.22018102 -5.98576532 -4.32596314 -3.58391898]
plot_data2 = randn(40).cumsum()
plot_data3 = randn(40).cumsum()
plot_data4 = randn(40).cumsum()

plt.plot(plot_data1, marker='o', color='red', linestyle='-', label='红实线')
plt.plot(plot_data2, marker='x', color='orange', linestyle='--', label='橙虚线')
plt.plot(plot_data3, marker='*', color='yellow', linestyle='-.', label='黄点线')
plt.plot(plot_data4, marker='s', color='green', linestyle=':', label='绿点图')

# loc='best'给label自动选择最好的位置
plt.legend(loc='best', prop=font)
plt.show()

四、散点图+直线图

[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]
# 拟合一条水平散点线
np.random.seed(1)
y_linear = x + 10 * np.random.randn(19)
print(y_linear)
[ 17.24345364  -4.11756414  -2.28171752  -6.72968622  13.65407629
 -17.01538697  24.44811764   0.38793099  12.19039096   7.50629625
  25.62107937  -8.60140709   9.77582796  10.15945645  26.33769442
   5.00108733  15.27571792   9.22141582  19.42213747]
# 拟合一条x²的散点线
y_quad = x**2 + 10 * np.random.randn(19)
print(y_quad)
[  6.82815214  -7.00619177  20.4472371   25.01590721  30.02494339
  45.00855949  42.16272141  62.77109774  71.64230566  97.3211192
 126.30355467 137.08339248 165.03246473 189.128273   216.54794359
 249.28753869 288.87335401 312.82689651 363.34415698]
# s是散点大小
fig = plt.figure()
ax1 = fig.add_subplot(121)
plt.scatter(x, y_linear, s=30, color='r', label='蓝点')
plt.scatter(x, y_quad, s=100, color='b', label='红点')

ax2 = fig.add_subplot(122)
plt.plot(x, y_linear, color='r')
plt.plot(x, y_quad, color='b')

# 限制x轴和y轴的范围取值
plt.xlim(min(x) - 1, max(x) + 1)
plt.ylim(min(y_quad) - 10, max(y_quad) + 10)
fig.suptitle('散点图+直线图', fontproperties=font, fontsize=20)
ax1.set_title('散点图', fontproperties=font)
ax1.legend(prop=font)
ax2.set_title('直线图', fontproperties=font)
plt.show()

re模块

正则表达式

什么是正则表达式

正则表达式本身是一种小型的、高度专业化的编程语言，它并不是Python的一部分。正则表达式是用于处理字符串的强大工具，拥有自己独特的语法以及一个独立的处理引擎，效率上可能不如str自带的方法，但功能十分强大。得益于这一点，在提供了正则表达式的语言里，正则表达式的语法都是一样的，区别只在于不同的编程语言实现支持的语法数量不同；但不用担心，不被支持的语法通常是不常用的部分。如果已经在其他语言里使用过正则表达式，只需要简单看一看就可以上手了。而在python中，通过内嵌集成re模块，程序员们可以直接调用来实现正则匹配。正则表达式模式被编译成一系列的字节码，然后由用C编写的匹配引擎执行。

正则表达式用途

用于对字符串或者数据进行筛选，也可以连用requests模块来进行爬虫

re模块得基本使用

正则表达式是用来匹配处理字符串的 python 中使用正则表达式需要引入re模块

import re  # 第一步，要引入re模块
a = re.findall("匹配规则", "这个字符串是否有匹配规则的字符")  # 第二步，调用模块函数
print(a)  # 以列表形式返回匹配到的字符串
['匹配规则']

^元字符

字符串开始位置与匹配规则符合就匹配，否则不匹配

匹配字符串开头。在多行模式中匹配每一行的开头（Python3+已经失效，配合compile使用）

^元字符如果写到[]字符集里就是反取

import re
a = re.findall("^匹配规则", "匹配规则这个字符串是否匹配")  # 字符串开始位置与匹配规则符合就匹配，否则不匹配
print(a)
#打印出 ['匹配规则']
['匹配规则']

[^a-z]反取

匹配出除字母外的字符，^元字符如果写到字符集里就是反取

import re
a = re.findall("[^a-z]", "匹配s规则这s个字符串是否s匹配f规则则re则则则")  # 反取，匹配出除字母外的字符
print(a)
['匹', '配', '规', '则', '这', '个', '字', '符', '串', '是', '否', '匹', '配', '规', '则', '则', '则', '则', '则']

$元字符

字符串结束位置与匹配规则符合就匹配，否则不匹配

匹配字符串末尾，在多行模式中匹配每一行的末尾

import re
a = re.findall("匹配规则$", "这个字符串是否匹配规则")  # 字符串结束位置与匹配规则符合就匹配，否则不匹配
print(a)
['匹配规则']

*元字符

需要字符串里完全符合，匹配规则，就匹配，（规则里的*元字符）前面的一个字符可以是0个或多个原本字符

匹配前一个字符0或多次，贪婪匹配前导字符有多少个就匹配多少个很贪婪

如果规则里只有一个分组，尽量避免用*否则会有可能匹配出空字符串

import re
# 需要字符串里完全符合，匹配规则，就匹配，（规则里的*元字符）前面的一个字符可以是0或多个原本字符
a = re.findall("匹配规则*", "这个字符串是否匹配规则则则则则")
print(a)
['匹配规则则则则则']

+元字符

需要字符串里完全符合，匹配规则，就匹配，（规则里的+元字符）前面的一个字符可以是1个或多个原本字符

匹配前一个字符1次或无限次，贪婪匹配前导字符有多少个就匹配多少个很贪婪

import re
# 需要字符串里完全符合，匹配规则，就匹配，（规则里的+元字符）前面的一个字符可以是1个或多个原本字符
a = re.findall("匹配+", "匹配配配配配规则这个字符串是否匹配规则则则则则")
print(a)
['匹配配配配配', '匹配']

?元字符(防止贪婪匹配)

需要字符串里完全符合，匹配规则，就匹配，（规则里的?元字符）前面的一个字符可以是0个或1个原本字符

匹配一个字符0次或1次

还有一个功能是可以防止贪婪匹配，详情见防贪婪匹配

import re
# 需要字符串里完全符合，匹配规则，就匹配，（规则里的?元字符）前面的一个字符可以是0个或1个原本字符
a = re.findall("匹配规则?", "匹配规这个字符串是否匹配规则则则则则")
print(a)
['匹配规', '匹配规则']

{}元字符(范围)

需要字符串里完全符合，匹配规则，就匹配，（规则里的 {} 元字符）前面的一个字符，是自定义字符数，位数的原本字符

{m}匹配前一个字符m次，{m,n}匹配前一个字符m至n次，若省略n，则匹配m至无限次

{0,}匹配前一个字符0或多次,等同于*元字符
{+,}匹配前一个字符1次或无限次,等同于+元字符
{0,1}匹配前一个字符0次或1次,等同于?元字符

import re
# {m}匹配前一个字符m次，{m,n}匹配前一个字符m至n次，若省略n，则匹配m至无限次
a = re.findall("匹配规则{3}", "匹配规这个字符串是否匹配规则则则则则")
print(a)
['匹配规则则则']

[]元字符(字符集)

需要字符串里完全符合，匹配规则，就匹配，（规则里的 [] 元字符）对应位置是[]里的任意一个字符就匹配

字符集。对应的位置可以是字符集中任意字符。字符集中的字符可以逐个列出，也可以给出范围，如[abc]或[a-c]。[^abc]表示取反，即非abc。
所有特殊字符在字符集中都失去其原有的特殊含义。用\反斜杠转义恢复特殊字符的特殊含义。

import re
# 需要字符串里完全符合，匹配规则，就匹配，（规则里的 [] 元字符）对应位置是[]里的任意一个字符就匹配
a = re.findall("匹配[a,b,c]规则", "匹配a规则这个字符串是否匹配b规则则则则则")
print(a)
['匹配a规则', '匹配b规则']

[^]

非，反取，匹配出除[^]里面的字符，^元字符如果写到字符集里就是反取

import re
a = re.findall("[^a-z]", "匹配s规则这s个字符串是否s匹配f规则则re则则则")  # 反取，匹配出除字母外的字符
print(a)
['匹', '配', '规', '则', '这', '个', '字', '符', '串', '是', '否', '匹', '配', '规', '则', '则', '则', '则', '则']

反斜杠后边跟普通字符实现特殊功能(预定义字符)

预定义字符是在字符集和组里都是有用的

\d匹配任何十进制数，它相当于类[0-9]

import re
a = re.findall("\d", "匹配规则这2个字符串3是否匹配规则5则则则7则")  # \d匹配任何十进制数，它相当于类[0-9]
print(a)
['2', '3', '5', '7']

\d+

匹配一位或者多位数的数字时用

import re
a = re.findall("\d+", "匹配规则这2个字符串134444是否匹配规则5则则则7则")  # \d+如果需要匹配一位或者多位数的数字时用
print(a)
['2', '134444', '5', '7']

匹配任何非数字字符，它相当于类[^0-9]

import re
a = re.findall("\D", "匹配规则这2个字符串3是否匹配规则5则则则7则")  # \D匹配任何非数字字符，它相当于类[^0-9]
print(a)
['匹', '配', '规', '则', '这', '个', '字', '符', '串', '是', '否', '匹', '配', '规', '则', '则', '则', '则', '则']

匹配任何空白字符，它相当于类[\t\n\r\f\v]

import re
# \s匹配任何空白字符，它相当于类[\t\n\r\f\v]
a = re.findall("\s", "匹配规则   这2个字符串3是否匹\n配规则5则则则7则")
print(a)
[' ', ' ', ' ', '\n']

匹配任何非空白字符，它相当于类[^\t\n\r\f\v]

import re
# \S匹配任何非空白字符，它相当于类[^\t\n\r\f\v]
a = re.findall("\S", "匹配规则   这2个字符串3是否匹\n配规则5则则则7则")
print(a)
['匹', '配', '规', '则', '这', '2', '个', '字', '符', '串', '3', '是', '否', '匹', '配', '规', '则', '5', '则', '则', '则', '7', '则']

匹配包括下划线在内任何字母数字字符，它相当于类[a-zA-Z0-9_]

import re
# \w匹配包括下划线在内任何字母数字字符，它相当于类[a-zA-Z0-9_]
a = re.findall('\w', "https://www.cnblogs.com/")
print(a)
['h', 't', 't', 'p', 's', 'w', 'w', 'w', 'c', 'n', 'b', 'l', 'o', 'g', 's', 'c', 'o', 'm']

匹配非任何字母数字字符包括下划线在内，它相当于类[^a-zA-Z0-9_]

import re
# \w匹配包括下划线在内任何字母数字字符，它相当于类[a-zA-Z0-9_]
a = re.findall('\W', "https://www.cnblogs.com/")
print(a)
[':', '/', '/', '.', '.', '/']

()元字符(分组)

也就是分组匹配，()里面的为一个组也可以理解成一个整体

如果()后面跟的是特殊元字符如 (adc)* 那么*控制的前导字符就是()里的整体内容，不再是前导一个字符

import re
# 也就是分组匹配，()里面的为一个组也可以理解成一个整体
a = re.search("(a4)+", "a4a4a4a4a4dg4g654gb")  # 匹配一个或多个a4
b = a.group()
print(b)
a4a4a4a4a4
import re
# 也就是分组匹配，()里面的为一个组也可以理解成一个整体
# 匹配 (a) (\d0-9的数字) (+可以是1个到多个0-9的数字)
a = re.search("a(\d+)", "a466666664a4a4a4dg4g654gb")
b = a.group()
print(b)
a466666664

|元字符(或)

|或，或就是前后其中一个符合就匹配

import re
a = re.findall(r"你|好", "a4a4a你4aabc4a4dgg好dg4g654g")  # |或，或就是前后其中一个符合就匹配
print(a)

re模块的方法

re.S

在Python的正则表达式中，有一个参数为re.S。它表示 “.” 的作用扩展到整个字符串，包括“\n”。看如下代码：

import re
a = '''asdfhellopass:
    worldaf
    '''
b = re.findall('hello(.*?)world', a)
c = re.findall('hello(.*?)world', a, re.S)
print('b is ', b)
print('c is ', c)
b is  []
c is  ['pass:\n    ']

正则表达式中，“.”的作用是匹配除“\n”以外的任何字符，也就是说，它是在一行中进行匹配。这里的“行”是以“\n”进行区分的。a字符串有每行的末尾有一个“\n”，不过它不可见。

如果不使用re.S参数，则只在每一行内进行匹配，如果一行没有，就换下一行重新开始，不会跨行。而使用re.S参数以后，正则表达式会将这个字符串作为一个整体，将“\n”当做一个普通的字符加入到这个字符串中，在整体中进行匹配。

re.I

不区分大小写

res = re.findall(r"A", "abc", re.I)
print(res)
['a']

re.sub

# 要求结果：['12', '23', '34']
l = ['1 2 ', '2   3', '  3 4']
import re
print(eval(re.sub(r'\s*', '', str

typing模块

typing模块的使用：

from typing import List, Tuple, Dict

typing模块的用途

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

注意：typing模块只有在python3.5以上的版本中才可以使用,pycharm目前支持typing检查

from typing import List, Tuple, Dict


def add(a: int, string: str, f: float,
        b: bool) -> Tuple[List, Tuple, Dict, bool]:
    list1 = list(range(a))
    tup = (string, string, string)
    d = {"a": f}
    bl = b
    return list1, tup, d, bl


print(add(5, "hhhh", 2.3, False))

typing的常用类型

int、long、float: 整型、长整形、浮点型
bool、str: 布尔型、字符串类型
List、 Tuple、 Dict、 Set:列表、元组、字典、集合
Iterable、Iterator:可迭代类型、迭代器类型
Generator：生成器类型

来源：https://www.cnblogs.com/ledgua/p/11378985.html

标签

字符数组

字符串函数

python正则表达式

python字符串操作

Python 常用模块介绍

time模块

time模块

时间戳

格式化时间（显示当前时间）

datetime模块

datetime模块

返回当前时间

通过datetime.timedelta添加来达到当前日期的加减模式：

默认加减天数，hours加减小时，minutes加减分钟

random模块

random模块

random模块方法

os模块

os模块

os模块常用方法

sys模块

sys模块

json模块

json模块

pickle模块

pickle模块

hashlib模块

hashlib模块

什么是hash：

hmac模块

hamc模块

hmac模块的使用方法

logging模块

logging模块

numpy模块

numpy模块

通过函数生成numpy数组

arange生成

zeros()/noes()生成

numpy数组运算函数

pandas模块

pandas模块

pandas常用属性方法 dateframe属性

matplotlib模块

re模块

正则表达式

什么是正则表达式

正则表达式用途

re模块得基本使用

re模块的方法

re.S

re.I

re.sub

typing模块

typing模块的使用：

typing模块的用途

typing的常用类型