一、time模块

1、1 时间戳

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

代码:

time_stamp = time.time() print(time_stamp, type(time_stamp))

1、2 格式化时间

格式化的时间字符串(format string):格式化时间表示的是普通的字符串格式的时间。

代码:

format_time = time.strftime("%Y-%m-%d %X") print(format_time, type(format_time))

结果:

2019-03-07 16:22:11 <class 'str'>

1、3 结构化时间

结构化的时间(struct time):struct_time元组共有9个元素共九个元素,分别为(年,月,日,时,分,秒,一年中第几周,一年中第几天,夏令时)

代码:

print('本地时区的struct_time:\n{}'.format(time.localtime())) print('UTC时区的struct_time:\n{}'.format(time.gmtime()))

本地时区的struct_time: time.struct_time(tm_year=2019, tm_mon=3, tm_mday=7, tm_hour=16, tm_min=22, tm_sec=11, tm_wday=3, tm_yday=66, tm_isdst=0) UTC时区的struct_time: time.struct_time(tm_year=2019, tm_mon=3, tm_mday=7, tm_hour=8, tm_min=22, tm_sec=11, tm_wday=3, tm_yday=66, tm_isdst=0)

代码:

# 结构化时间的基准时间 print(time.localtime(0))

time.struct_time(tm_year=1971, tm_mon=1, tm_mday=1, tm_hour=8, tm_min=0, tm_sec=0, tm_wday=4, tm_yday=1, tm_isdst=0)

1、4 不同格式化时间的转化

  如上图所示,我们总能通过某些方法在结构化时间-格式化时间-时间戳三者之间进行转换,下面我们将用代码展示如何通过这些方法转换时间格式。

# 结构化时间
now_time = time.localtime()
print(now_time)
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=7, tm_hour=16, tm_min=22, tm_sec=11, tm_wday=3, tm_yday=66, tm_isdst=0)
# 把结构化时间转换为时间戳格式
print(time.mktime(now_time))
1551946931.0
# 把结构化时间转换为格式化时间
# %Y年-%m月-%d天 %X时分秒=%H时:%M分:%S秒
print(time.strftime("%Y-%m-%d %X", now_time))
2019-03-07 16:22:11
# 把格式化时间化为结构化时间,它和strftime()是逆操作
print(time.strptime('2013-05-20 13:14:52', '%Y-%m-%d %X'))
time.struct_time(tm_year=2013, tm_mon=5, tm_mday=20, tm_hour=13, tm_min=14, tm_sec=52, tm_wday=0, tm_yday=140, tm_isdst=-1)
# 把结构化时间表示为这种形式:'Sun Jun 20 23:21:05 1993'。
print(time.asctime())
Thu Mar 7 16:22:11 2019
# 如果没有参数,将会将time.localtime()作为参数传入。
print(time.asctime(time.localtime()))
Thu Mar 7 16:22:11 2019
# 把一个时间戳转化为time.asctime()的形式。
print(time.ctime())
Thu Mar 7 16:22:11 2019
# 如果参数未给或者为None的时候,将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。
print(time.ctime(time.time()))
Thu Mar 7 16:22:11 2019

1、5 其他用法

推迟指定的时间运行,单位为秒 start = time.time() time.sleep(3) end = time.time() print(end-start)

二、datetime模块

# datetime模块可以看成是时间加减的模块
import datetime
# 返回当前时间
print(datetime.datetime.now())
2019-03-07 16:22:14.544130
print(datetime.date.fromtimestamp(time.time()))
2019-03-07
# 当前时间+3天
print(datetime.datetime.now() + datetime.timedelta(3))
2019-03-10 16:22:14.560599
# 当前时间-3天
print(datetime.datetime.now() + datetime.timedelta(-3))
2019-03-04 16:22:14.568473
# 当前时间-3小时
print(datetime.datetime.now() + datetime.timedelta(hours=3))
2019-03-07 19:22:14.575881
# 当前时间+30分钟
print(datetime.datetime.now() + datetime.timedelta(minutes=30))
2019-03-07 16:52:14.585432
# 时间替换
c_time = datetime.datetime.now()
print(c_time.replace(minute=20, hour=5, second=13))
2019-03-07 05:20:13.595493

三、random模块

import random
# 大于0且小于1之间的小数
print(random.random())
0.42866657593385415
# 大于等于1且小于等于3之间的整数
print(random.randint(1, 3))
3
# 大于等于1且小于3之间的整数
print(random.randrange(1, 3))
2
# 大于1小于3的小数,如1.927109612082716
print(random.uniform(1, 3))
2.1789596280319605
# 列表内的任意一个元素,即1或者‘23’或者[4,5]
print(random.choice([1, '23', [4, 5]]))
[4, 5]
# random.sample([], n),列表元素任意n个元素的组合,示例n=2
print(random.sample([1, '23', [4, 5]], 2))
['23', 1]
lis = [1, 3, 5, 7, 9]
# 打乱l的顺序,相当于"洗牌"
random.shuffle(lis)
print(lis)
[9, 1, 5, 7, 3]

四、os模块

os模块负责程序与操作系统的交互,提供了访问操作系统底层的接口,多用于文件处理。

方法详解
os.getcwd() 获取当前工作目录,即当前python脚本工作的目录路径
os.chdir("dirname") 改变当前脚本工作目录;相当于shell下cd
os.curdir 返回当前目录: ('.')
os.pardir 获取当前目录的父目录字符串名:('..')
os.makedirs('dirname1/dirname2') 可生成多层递归目录
os.removedirs('dirname1') 若目录为空,则删除,并递归到上一级目录,如若也为空,则删除,依此类推
os.mkdir('dirname') 生成单级目录;相当于shell中mkdir dirname
os.rmdir('dirname') 删除单级空目录,若目录不为空则无法删除,报错;相当于shell中rmdir dirname
os.listdir('dirname') 列出指定目录下的所有文件和子目录,包括隐藏文件,并以列表方式打印
os.remove() 删除一个文件
os.rename("oldname","newname") 重命名文件/目录
os.stat('path/filename') 获取文件/目录信息
os.sep 输出操作系统特定的路径分隔符,win下为"",Linux下为"/"
os.linesep 输出当前平台使用的行终止符,win下为"\t\n",Linux下为"\n"
os.pathsep 输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command") 运行shell命令,直接显示
os.environ 获取系统环境变量
os.path.abspath(path) 返回path规范化的绝对路径
os.path.split(path) 将path分割成目录和文件名二元组返回
os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path) 返回path最后的文件名。如何path以/或\结尾,那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path) 如果path存在,返回True;如果path不存在,返回False
os.path.isabs(path) 如果path是绝对路径,返回True
os.path.isfile(path) 如果path是一个存在的文件,返回True。否则返回False
os.path.isdir(path) 如果path是一个存在的目录,则返回True。否则返回False
os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回,第一个绝对路径之前的参数将被忽略
os.path.getatime(path) 返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间

os.path.getsize(path) 返回path的大小

五、sys模块

sys模块负责程序与python解释器的交互,提供了一系列的函数和变量,用于操控python的运行时环境。

方法详解
sys.argv 命令行参数List,第一个元素是程序本身路径
sys.modules.keys() 返回所有已经导入的模块列表
sys.exc_info() 获取当前正在处理的异常类,exc_type、exc_value、exc_traceback当前处理的异常详细信息
sys.exit(n) 退出程序,正常退出时exit(0)
sys.hexversion 获取Python解释程序的版本值,16进制格式如:0x020403F0
sys.version 获取Python解释程序的版本信息
sys.maxint 最大的Int值
sys.maxunicode 最大的Unicode值
sys.modules 返回系统导入的模块字段,key是模块名,value是模块
sys.path 返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
sys.platform 返回操作系统平台名称
sys.stdout 标准输出
sys.stdin 标准输入
sys.stderr 错误输出
sys.exc_clear() 用来清除当前线程所出现的当前的或最近的错误信息
sys.exec_prefix 返回平台独立的python文件安装的位置
sys.byteorder 本地字节规则的指示器,big-endian平台的值是'big',little-endian平台的值是'little'
sys.copyright 记录python版权相关的东西
sys.api_version 解释器的C的API版本

六、json和pickle模块

6.1 序列化

把对象(变量)从内存中变成可存储或传输的过程称之为序列化,在Python中叫pickling,在其他语言中也被称之为serialization,marshalling,flattening。

序列化的优点:

  1. 持久保存状态:内存是无法永久保存数据的,当程序运行了一段时间,我们断电或者重启程序,内存中关于这个程序的之前一段时间的数据(有结构)都被清空了。但是在断电或重启程序之前将程序当前内存中所有的数据都保存下来(保存到文件中),以便于下次程序执行能够从文件中载入之前的数据,然后继续执行,这就是序列化。

  2. 跨平台数据交互:序列化时不仅可以把序列化后的内容写入磁盘,还可以通过网络传输到别的机器上,如果收发的双方约定好实用一种序列化的格式,那么便打破了平台/语言差异化带来的限制,实现了跨平台数据交互。

6.2 json

Json序列化并不是python独有的,json序列化在java等语言中也会涉及到,因此使用json序列化能够达到跨平台传输数据的目的。

json数据类型和python数据类型对应关系表

Json类型Python类型
{} dict
[] list
"string" str
520.13 int或float
true/false True/False
null None

json模块序列化和反序列化的一个过程如下图所示

import json
struct_data = {'name': 'json', 'age': 23, 'sex': 'male'}
print(struct_data, type(struct_data))
{'name': 'json', 'age': 23, 'sex': 'male'} <class 'dict'>
data = json.dumps(struct_data)
print(data, type(data))
{"name": "json", "age": 23, "sex": "male"} <class 'str'>
# 注意:无论数据是怎样创建的,只要满足json格式(如果是字典,则字典内元素都是双引号),就可以json.loads出来,不一定非要dumps的数据才能loads
data = json.loads(data)
print(data, type(data))
{'name': 'json', 'age': 23, 'sex': 'male'} <class 'dict'>
# 序列化
with open('Json序列化对象.json', 'w') as fw:
   json.dump(struct_data, fw)
# 反序列化
with open('Json序列化对象.json') as fr:
   data = json.load(fr)
print(data)
{'name': 'json', 'age': 23, 'sex': 'male'}

6.3 pickle

Pickle序列化和所有其他编程语言特有的序列化问题一样,它只能用于Python,并且可能不同版本的Python彼此都不兼容,因此,只能用Pickle保存那些不重要的数据,即不能成功地反序列化也没关系。但是pickle的好处是可以存储Python中的所有的数据类型,包括对象,而json不可以。

pickle模块序列化和反序列化的过程如下图所示

import pickle
struct_data = {'name': 'json', 'age': 23, 'sex': 'male'}
print(struct_data, type(struct_data))
{'name': 'json', 'age': 23, 'sex': 'male'} <class 'dict'>
data = pickle.dumps(struct_data)
print(data, type(data))
b'\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\x04\x00\x00\x00jsonq\x02X\x03\x00\x00\x00ageq\x03K\x17X\x03\x00\x00\x00sexq\x04X\x04\x00\x00\x00maleq\x05u.' <class 'bytes'>
data = pickle.loads(data)
print(data, type(data))
{'name': 'json', 'age': 23, 'sex': 'male'} <class 'dict'>
# 序列化(注意: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)
{'name': 'json', 'age': 23, 'sex': 'male'}

七、hashlib和hmac模块

7、1 hash是什么

hash是一种算法(Python3.版本里使用hashlib模块代替了md5模块和sha模块,主要提供 SHA1、SHA224、SHA256、SHA384、SHA512、MD5 算法),该算法接受传入的内容,经过运算得到一串hash值。

hash值的特点:

  1. 只要传入的内容一样,得到的hash值一样,可用于非明文密码传输时密码校验

  2. 不能由hash值返解成内容,即可以保证非明文密码的安全性

  3. 只要使用的hash算法不变,无论校验的内容有多大,得到的hash值长度是固定的,可以用于对文本的哈希处理

hash算法其实可以看成如下图所示的一座工厂,工厂接收你送来的原材料,经过加工返回的产品就是hash值

import hashlib
m = hashlib.md5()

m.update('hello'.encode('utf8'))
print(m.hexdigest())
5d41402abc4b2a76b9719d911017c592
m.update('hash'.encode('utf8'))
print(m.hexdigest())
97fa850988687b8ceb12d773347f7712
m2 = hashlib.md5()
m2.update('hellohash'.encode('utf8'))
print(m2.hexdigest())
97fa850988687b8ceb12d773347f7712
m3 = hashlib.md5()
m3.update('hello'.encode('utf8'))
print(m3.hexdigest())
5d41402abc4b2a76b9719d911017c592

7、2 撞库破解hash算法加密

hash加密算法虽然看起来很厉害,但是他是存在一定缺陷的,即可以通过撞库可以反解,如下代码所示。

import hashlib

# 假定我们知道hash的微信会设置如下几个密码
pwd_list = [
  'hash3714',
  'hash1313',
  'hash94139413',
  'hash123456',
  '123456hash',
  'h123ash',
]


def make_pwd_dic(pwd_list):
  dic = {}
  for pwd in pwd_list:
      m = hashlib.md5()
      m.update(pwd.encode('utf-8'))
      dic[pwd] = m.hexdigest()
  return dic


def break_code(hash_pwd, pwd_dic):
  for k, v in pwd_dic.items():
      if v == hash_pwd:
          print('hash的微信的密码是===>%s' % k)


hash_pwd = '0562b36c3c5a3925dbe3c4d32a4f2ba2'
break_code(hash_pwd, make_pwd_dic(pwd_list))
hash的微信的密码是===>hash123456

为了防止密码被撞库,我们可以使用python中的另一个hmac 模块,它内部对我们创建key和内容做过某种处理后再加密。

如果要保证hmac模块最终结果一致,必须保证:

  1. hmac.new括号内指定的初始key一样

  2. 无论update多少次,校验的内容累加到一起是一样的内容

import hmac

# 注意hmac模块只接受二进制数据的加密
h1 = hmac.new(b'hash')
h1.update(b'hello')
h1.update(b'world')
print(h1.hexdigest())
905f549c5722b5850d602862c34a763e
h2 = hmac.new(b'hash')
h2.update(b'helloworld')
print(h2.hexdigest())
905f549c5722b5850d602862c34a763e
h3 = hmac.new(b'hashhelloworld')
print(h3.hexdigest())
a7e524ade8ac5f7f33f3a39a8f63fd25

八、logging模块

8、1 低配logging

日志总共分为以下五个级别,这个五个级别自下而上进行匹配 debug-->info-->warning-->error-->critical,默认最低级别为warning级别。

8.1.1 v1

import logging

logging.debug('调试信息')
logging.info('正常信息')
logging.warning('警告信息')
logging.error('报错信息')
logging.critical('严重错误信息')
WARNING:root:警告信息
ERROR:root:报错信息
CRITICAL:root:严重错误信息

v1版本无法指定日志的级别;无法指定日志的格式;只能往屏幕打印,无法写入文件。因此可以改成下述的代码。

8.1.2 v2

import logging

# 日志的基本配置

logging.basicConfig(filename='access.log',
                  format='%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
                  datefmt='%Y-%m-%d %H:%M:%S %p',
                  level=10)

logging.debug('调试信息') # 10
logging.info('正常信息') # 20
logging.warning('警告信息') # 30
logging.error('报错信息') # 40
logging.critical('严重错误信息') # 50
可在logging.basicConfig()函数中可通过具体参数来更改logging模块默认行为,可用参数有:
   
filename:用指定的文件名创建FiledHandler(后边会具体讲解handler的概念),这样日志会被存储在指定的文件中。
filemode:文件打开方式,在指定了filename时使用这个参数,默认值为“a”还可指定为“w”。
format:指定handler使用的日志显示格式。
datefmt:指定日期时间格式。
level:设置rootlogger(后边会讲解具体概念)的日志级别
stream:用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件,默认为sys.stderr。若同时列出了filename和stream两个参数,则stream参数会被忽略。


format参数中可能用到的格式化串:

%(name)s Logger的名字
%(levelno)s 数字形式的日志级别
%(levelname)s 文本形式的日志级别
%(pathname)s 调用日志输出函数的模块的完整路径名,可能没有
%(filename)s 调用日志输出函数的模块的文件名
%(module)s 调用日志输出函数的模块名
%(funcName)s 调用日志输出函数的函数名
%(lineno)d 调用日志输出函数的语句所在的代码行
%(created)f 当前时间,用UNIX标准的表示时间的浮 点数表示
%(relativeCreated)d 输出日志信息时的,自Logger创建以 来的毫秒数
%(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
%(thread)d 线程ID。可能没有
%(threadName)s 线程名。可能没有
%(process)d 进程ID。可能没有
%(message)s用户输出的消息

v2版本不能指定字符编码;只能往文件中打印。

8.1.3 v3

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

  1. logger:产生日志的对象

  2. Filter:过滤日志的对象

  3. Formatter对象:可以定制不同的日志格式对象,然后绑定给不同的Handler对象使用,以此来控制不同的Handler的日志格式

  4. Handler:接收日志然后控制打印到不同的地方,FileHandler用来打印到文件中,StreamHandler用来打印到终端

'''
critical=50
error =40
warning =30
info = 20
debug =10
'''


import logging

# 1、logger对象:负责产生日志,然后交给Filter过滤,然后交给不同的Handler输出
logger = logging.getLogger(__file__)

# 2、Filter对象:不常用,略

# 3、Handler对象:接收logger传来的日志,然后控制输出
h1 = logging.FileHandler('t1.log') # 打印到文件
h2 = logging.FileHandler('t2.log') # 打印到文件
sm = logging.StreamHandler() # 打印到终端

# 4、Formatter对象:日志格式
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',)


# 5、为Handler对象绑定格式
h1.setFormatter(formmater1)
h2.setFormatter(formmater2)
sm.setFormatter(formmater3)

# 6、将Handler添加给logger并设置日志级别
logger.addHandler(h1)
logger.addHandler(h2)
logger.addHandler(sm)

# 设置日志级别,可以在两个关卡进行设置logger与handler
# logger是第一级过滤,然后才能到handler
logger.setLevel(30)
h1.setLevel(10)
h2.setLevel(10)
sm.setLevel(10)

# 7、测试
logger.debug('debug')
logger.info('info')
logger.warning('warning')
logger.error('error')
logger.critical('critical')

8、2 高配logging

8.2.1 配置日志文件

以上三个版本的日志只是为了引出我们下面的日志配置文件

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:\Users\oldboy\Desktop\atm\log

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

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

# log文件的全路径
logfile_path = os.path.join(logfile_dir, logfile_name) # C:\Users\oldboy\Desktop\atm\log\log.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()

8.2.2 使用日志

import time
import logging
import my_logging # 导入自定义的logging配置

logger = logging.getLogger(__name__) # 生成logger实例


def demo():
  logger.debug("start range... time:{}".format(time.time()))
  logger.info("中文测试开始。。。")
  for i in range(10):
      logger.debug("i:{}".format(i))
      time.sleep(0.2)
  else:
      logger.debug("over range... time:{}".format(time.time()))
  logger.info("中文测试结束。。。")


if __name__ == "__main__":
  my_logging.load_my_logging_cfg() # 在你程序文件的入口加载自定义logging配置
  demo()

8、3Django日志配置文件

# logging_config.py

LOGGING = {
   'version': 1,
   'disable_existing_loggers': False,
   'formatters': {
       'standard': {
           'format': '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]'
                     '[%(levelname)s][%(message)s]'
      },
       'simple': {
           'format': '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
      },
       'collect': {
           'format': '%(message)s'
      }
  },
   'filters': {
       'require_debug_true': {
           '()': 'django.utils.log.RequireDebugTrue',
      },
  },
   'handlers': {
       # 打印到终端的日志
       'console': {
           'level': 'DEBUG',
           'filters': ['require_debug_true'],
           'class': 'logging.StreamHandler',
           'formatter': 'simple'
      },
       # 打印到文件的日志,收集info及以上的日志
       'default': {
           'level': 'INFO',
           'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件,自动切
           'filename': os.path.join(BASE_LOG_DIR, "xxx_info.log"),  # 日志文件
           'maxBytes': 1024 * 1024 * 5,  # 日志大小 5M
           'backupCount': 3,
           'formatter': 'standard',
           'encoding': 'utf-8',
      },
       # 打印到文件的日志:收集错误及以上的日志
       'error': {
           'level': 'ERROR',
           'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件,自动切
           'filename': os.path.join(BASE_LOG_DIR, "xxx_err.log"),  # 日志文件
           'maxBytes': 1024 * 1024 * 5,  # 日志大小 5M
           'backupCount': 5,
           'formatter': 'standard',
           'encoding': 'utf-8',
      },
       # 打印到文件的日志
       'collect': {
           'level': 'INFO',
           'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件,自动切
           'filename': os.path.join(BASE_LOG_DIR, "xxx_collect.log"),
           'maxBytes': 1024 * 1024 * 5,  # 日志大小 5M
           'backupCount': 5,
           'formatter': 'collect',
           'encoding': "utf-8"
      }
  },
   'loggers': {
       # logging.getLogger(__name__)拿到的logger配置
       '': {
           'handlers': ['default', 'console', 'error'],
           'level': 'DEBUG',
           'propagate': True,
      },
       # logging.getLogger('collect')拿到的logger配置
       'collect': {
           'handlers': ['console', 'collect'],
           'level': 'INFO',
      }
  },
}


# -----------
# 用法:拿到俩个logger

logger = logging.getLogger(__name__)  # 线上正常的日志
collect_logger = logging.getLogger("collect")  # 领导说,需要为领导们单独定制领导们看的日志

九、numpy模块

9、1 numpy简介

numpy官方文档:https://docs.scipy.org/doc/numpy/reference/?v=20190307135750

numpy是Python的一种开源的数值计算扩展库。这种库可用来存储和处理大型numpy数组,比Python自身的嵌套列表结构要高效的多(该结构也可以用来表示numpy数组)。

numpy库有两个作用:

  1. 区别于list列表,提供了数组操作、数组运算、以及统计分布和简单的数学模型

  2. 计算速度快,甚至要由于python内置的简单运算,使得其成为pandas、sklearn等模块的依赖包。高级的框架如TensorFlow、PyTorch等,其数组操作也和numpy非常相似。

9、2 为什么用numpy

lis1 = [1, 2, 3]
lis2 = [4, 5, 6]
lis1
[1, 2, 3]
lis2
[4, 5, 6]

如果我们想让lis1 * lis2得到一个结果为lis_res = [4, 10, 18],非常复杂。

9、3 创建numpy数组

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

import numpy as np
# np.array? 相当于pycharm的ctrl+鼠标左键
# 创建一维的ndarray对象
arr = np.array([1, 2, 3])
print(arr, type(arr))
[1 2 3] <class 'numpy.ndarray'>
# 创建二维的ndarray对象
print(np.array([[1, 2, 3], [4, 5, 6]]))
[[1 2 3]
[4 5 6]]
# 创建三维的ndarray对象
print(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))
[[1 2 3]
[4 5 6]
[7 8 9]]

9、4 numpy数组的常用属性

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

dtype种类:bool_, int(8,16,32,64), float(16,32,64)

arr = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.float32)
print(arr)
[[1. 2. 3.]
[4. 5. 6.]]
print(arr.T)
[[1. 4.]
[2. 5.]
[3. 6.]]
print(arr.dtype)
float32
arr = arr.astype(np.int32)
print(arr.dtype)
print(arr)
int32
[[1 2 3]
[4 5 6]]
print(arr.size)
6
print(arr.ndim)
2
print(arr.shape)
(2, 3)

9、5 获取numpy数组的行列数

由于numpy数组是多维的,对于二维的数组而言,numpy数组就是既有行又有列。

注意:对于numpy我们一般多讨论二维的数组。

arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr)
[[1 2 3]
[4 5 6]]
# 获取numpy数组的行和列构成的数组
print(arr.shape)
(2, 3)
# 获取numpy数组的行
print(arr.shape[0])
2
# 获取numpy数组的列
print(arr.shape[1])
3

9、6 切割numpy数组

切分numpy数组类似于列表的切割,但是与列表的切割不同的是,numpy数组的切割涉及到行和列的切割,但是两者切割的方式都是从索引0开始,并且取头不取尾。

arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
print(arr)
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
# 取所有元素
print(arr[:, :])
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
# 取第一行的所有元素
print(arr[:1, :])
[[1 2 3 4]]
# 取第一行的所有元素
print(arr[0, [0, 1, 2, 3]])
[1 2 3 4]
# 取第一列的所有元素
print(arr[:, :1])
[[1]
[5]
[9]]
# 取第一列的所有元素
print(arr[(0, 1, 2), 0])
[1 5 9]
# 取第一行第一列的元素
print(arr[(0, 1, 2), 0])
[1 5 9]
# 取第一行第一列的元素
print(arr[0, 0])
1
# 取大于5的元素,返回一个数组
print(arr[arr > 5])
[ 6 7 8 9 10 11 12]
# numpy数组按运算符取元素的原理,即通过arr > 5生成一个布尔numpy数组
print(arr > 5)
[[False False False False]
[False True True True]
[ True True True True]]

9、7 numpy数组元素替换

numpy数组元素的替换,类似于列表元素的替换,并且numpy数组也是一个可变类型的数据,即如果对numpy数组进行替换操作,会修改原numpy数组的元素,所以下面我们用.copy()方法举例numpy数组元素的替换。

arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
print(arr)
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
# 取第一行的所有元素,并且让第一行的元素都为0
arr1 = arr.copy()
arr1[:1, :] = 0
print(arr1)
[[ 0 0 0 0]
[ 5 6 7 8]
[ 9 10 11 12]]
# 取所有大于5的元素,并且让大于5的元素为0
arr2 = arr.copy()
arr2[arr > 5] = 0
print(arr2)
[[1 2 3 4]
[5 0 0 0]
[0 0 0 0]]
# 对numpy数组清零
arr3 = arr.copy()
arr3[:, :] = 0
print(arr3)
[[0 0 0 0]
[0 0 0 0]
[0 0 0 0]]

9、8 numpy数组的合并

arr1 = np.array([[1, 2], [3, 4], [5, 6]])
print(arr1)
[[1 2]
[3 4]
[5 6]]
arr2 = np.array([[7, 8], [9, 10], [11, 12]])
print(arr2)
[[ 7 8]
[ 9 10]
[11 12]]
# 合并两个numpy数组的行,注意使用hstack()方法合并numpy数组,numpy数组应该有相同的行,其中hstack的h表示horizontal水平的
print(np.hstack((arr1, arr2)))
[[ 1 2 7 8]
[ 3 4 9 10]
[ 5 6 11 12]]
# 合并两个numpy数组,其中axis=1表示合并两个numpy数组的行
print(np.concatenate((arr1, arr2), axis=1))
[[ 1 2 7 8]
[ 3 4 9 10]
[ 5 6 11 12]]
# 合并两个numpy数组的列,注意使用vstack()方法合并numpy数组,numpy数组应该有相同的列,其中vstack的v表示vertical垂直的
print(np.vstack((arr1, arr2)))
[[ 1 2]
[ 3 4]
[ 5 6]
[ 7 8]
[ 9 10]
[11 12]]
# 合并两个numpy数组,其中axis=0表示合并两个numpy数组的列
print(np.concatenate((arr1, arr2), axis=0))
[[ 1 2]
[ 3 4]
[ 5 6]
[ 7 8]
[ 9 10]
[11 12]]

9、9 通过函数创建numpy数组

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

9.9.1 array

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

9.9.2 arange

# 构造0-9的ndarray数组
print(np.arange(10))
[0 1 2 3 4 5 6 7 8 9]
# 构造1-4的ndarray数组
print(np.arange(1, 5))
[1 2 3 4]
# 构造1-19且步长为2的ndarray数组
print(np.arange(1, 20, 2))
[ 1 3 5 7 9 11 13 15 17 19]

9.9.3 linspace/logspace

# 构造一个等差数列,取头也取尾,从0取到20,取5个数
print(np.linspace(0, 20, 5))
[ 0. 5. 10. 15. 20.]
# 构造一个等比数列,从10**0取到10**20,取5个数
print(np.logspace(0, 20, 5))
[1.e+00 1.e+05 1.e+10 1.e+15 1.e+20]

9.9.4 zeros/ones/eye/empty

# 构造3*4的全0numpy数组
print(np.zeros((3, 4)))
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
# 构造3*4的全1numpy数组
print(np.ones((3, 4)))
[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]
# 构造3个主元的单位numpy数组
print(np.eye(3))
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
# 构造一个4*4的随机numpy数组,里面的元素是随机生成的
print(np.empty((4, 4)))
[[ 2.31584178e+077 -1.49457545e-154 3.95252517e-323 0.00000000e+000]
[ 0.00000000e+000 0.00000000e+000 0.00000000e+000 0.00000000e+000]
[ 0.00000000e+000 0.00000000e+000 0.00000000e+000 0.00000000e+000]
[ 0.00000000e+000 0.00000000e+000 1.29074055e-231 1.11687366e-308]]

9.9.5 reshape

arr = np.ones([2, 2], dtype=int)
print(arr.reshape(4, 1))
[[1]
[1]
[1]
[1]]

9.9.6 fromstring/fromfunction(了解)

# fromstring通过对字符串的字符编码所对应ASCII编码的位置,生成一个ndarray对象
s = 'abcdef'
# np.int8表示一个字符的字节数为8
print(np.fromstring(s, dtype=np.int8))
[ 97 98 99 100 101 102]


/Applications/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:4: DeprecationWarning: The binary mode of fromstring is deprecated, as it behaves surprisingly on unicode inputs. Use frombuffer instead
after removing the cwd from sys.path.
def func(i, j):
  """其中i为numpy数组的行,j为numpy数组的列"""
  return i * j


# 使用函数对numpy数组元素的行和列的索引做处理,得到当前元素的值,索引从0开始,并构造一个3*4的numpy数组
print(np.fromfunction(func, (3, 4)))
[[0. 0. 0. 0.]
[0. 1. 2. 3.]
[0. 2. 4. 6.]]

9、10 numpy数组运算

运算符说明
+ 两个numpy数组对应元素相加
- 两个numpy数组对应元素相减
* 两个numpy数组对应元素相乘
/ 两个numpy数组对应元素相除,如果都是整数则取商
% 两个numpy数组对应元素相除后取余数
**n 单个numpy数组每个元素都取n次方,如**2:每个元素都取平方
arrarr1 = np.array([[1, 2], [3, 4], [5, 6]])
print(arr1)
[[1 2]
[3 4]
[5 6]]
arr2 = np.array([[7, 8], [9, 10], [11, 12]])
print(arr2)
[[ 7 8]
[ 9 10]
[11 12]]
print(arr1 + arr2)
[[ 8 10]
[12 14]
[16 18]]
print(arr1**2)
[[ 1 4]
[ 9 16]
[25 36]]

9、11 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−−√x

一元函数:abs, sqrt, exp, log, ceil, floor, rint, trunc, modf, isnan, isinf, cos, sin, tan

二元函数:add, substract, multiply, divide, power, mod, maximum, mininum

arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
print(arr)
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
# 对numpy数组的所有元素取正弦
print(np.sin(arr))
[[ 0.84147098 0.90929743 0.14112001 -0.7568025 ]
[-0.95892427 -0.2794155   0.6569866   0.98935825]
[ 0.41211849 -0.54402111 -0.99999021 -0.53657292]]
# 对numpy数组的所有元素开根号
print(np.sqrt(arr))
[[1.         1.41421356 1.73205081 2.       ]
[2.23606798 2.44948974 2.64575131 2.82842712]
[3.         3.16227766 3.31662479 3.46410162]]
# 对numpy数组的所有元素取反正弦,如果元素不在定义域内,则会取nan值
print(np.arcsin(arr * 0.1))
[[0.10016742 0.20135792 0.30469265 0.41151685]
[0.52359878 0.64350111 0.7753975 0.92729522]
[1.11976951 1.57079633       nan       nan]]


/Applications/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:2: RuntimeWarning: invalid value encountered in arcsin
 
# 判断矩阵元素中是否含有np.nan值
print(np.isnan(arr))
[[False False False]
[False False False]]

9、12 numpy数组矩阵化

9.12.1 numpy数组的点乘

numpy数组的点乘必须满足第一个numpy数组的列数等于第二个numpy数组的行数,即m∗n⋅n∗m=m∗mm∗n·n∗m=m∗m。

arr1 = np.array([[1, 2, 3], [4, 5, 6]])
print(arr1.shape)
(2, 3)
arr2 = np.array([[7, 8], [9, 10], [11, 12]])
print(arr2.shape)
(3, 2)
assert arr1.shape[0] == arr2.shape[1]
# 2*3·3*2 = 2*2
print(arr2.shape)
(3, 2)

9.12.2 numpy数组的转置

numpy数组的转置,相当于numpy数组的行和列互换。

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

9.12.3 numpy数组的逆

numpy数组行和列相同时,numpy数组才可逆。

arr = np.array([[1, 2, 3], [4, 5, 6], [9, 8, 9]])
print(arr)
[[1 2 3]
[4 5 6]
[9 8 9]]
print(np.linalg.inv(arr))
[[ 0.5       -1.         0.5       ]
[-3.         3.         -1.       ]
[ 2.16666667 -1.66666667 0.5       ]]
# 单位numpy数组的逆是单位numpy数组本身
arr = np.eye(3)
print(arr)
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
print(np.linalg.inv(arr))
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]

9、13 numpy数组数学和统计方法

方法详解
sum 求和
cumsum 累加求和
mean 求平均数
std 求标准差
var 求方差
min 求最小值
max 求最大值
argmin 求最小值索引
argmax 求最大值索引
sort 排序

9.13.1 最大最小值

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr)
[[1 2 3]
[4 5 6]
[7 8 9]]
# 获取numpy数组所有元素中的最大值
print(arr.max())
9
# 获取numpy数组所有元素中的最小值
print(arr.min())
1
# 获取举着每一行的最大值
print(arr.max(axis=0))
[7 8 9]
# 获取numpy数组每一列的最大值
print(arr.max(axis=1))
[3 6 9]
# 获取numpy数组最大元素的索引位置
print(arr.argmax(axis=1))
[2 2 2]

9.13.2 平均值

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr)
[[1 2 3]
[4 5 6]
[7 8 9]]
# 获取numpy数组所有元素的平均值
print(arr.mean())
5.0
# 获取numpy数组每一列的平均值
print(arr.mean(axis=0))
[4. 5. 6.]
# 获取numpy数组每一行的平均值
print(arr.mean(axis=1))
[2. 5. 8.]

9.13.3 方差

方差公式为

mean(|x−x.mean()|2)mean(|x−x.mean()|2)

其中x为numpy数组。

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr)
[[1 2 3]
[4 5 6]
[7 8 9]]
# 获取numpy数组所有元素的方差
print(arr.var())
6.666666666666667
# 获取numpy数组每一列的元素的方差
print(arr.var(axis=0))
[6. 6. 6.]
# 获取numpy数组每一行的元素的方差
print(arr.var(axis=1))
[0.66666667 0.66666667 0.66666667]

9.13.4 标准差

标准差公式为

mean|x−x.mean()|2−−−−−−−−−−−−−−−−−√=x.var()−−−−−−√mean|x−x.mean()|2=x.var()

 

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr)
[[1 2 3]
[4 5 6]
[7 8 9]]
# 获取numpy数组所有元素的标准差
print(arr.std())
2.581988897471611
# 获取numpy数组每一列的标准差
print(arr.std(axis=0))
[2.44948974 2.44948974 2.44948974]
# 获取numpy数组每一行的标准差
print(arr.std(axis=1))
[0.81649658 0.81649658 0.81649658]

9.13.5 中位数

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr)
[[1 2 3]
[4 5 6]
[7 8 9]]
# 获取numpy数组所有元素的中位数
print(np.median(arr))
5.0
# 获取numpy数组每一列的中位数
print(np.median(arr, axis=0))
[4. 5. 6.]
# 获取numpy数组每一行的中位数
print(np.median(arr, axis=1))
[2. 5. 8.]

9.13.6 numpy数组求和

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr)
[[1 2 3]
[4 5 6]
[7 8 9]]
# 对numpy数组的每一个元素求和
print(arr.sum())
45
# 对numpy数组的每一列求和
print(arr.sum(axis=0))
[12 15 18]
# 对numpy数组的每一行求和
print(arr.sum(axis=1))
[ 6 15 24]

9.13.7 累加和

arr = np.array([1, 2, 3, 4, 5])
print(arr)
[1 2 3 4 5]
# 第n个元素为前n-1个元素累加和
print(arr.cumsum())
[ 1 3 6 10 15]

9、14 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为指定数组
# RandomState()方法会让数据值随机一次,之后都是相同的数据
rs = np.random.RandomState(1)
print(rs.rand(10))
[4.17022005e-01 7.20324493e-01 1.14374817e-04 3.02332573e-01
1.46755891e-01 9.23385948e-02 1.86260211e-01 3.45560727e-01
3.96767474e-01 5.38816734e-01]
# 构造3*4的均匀分布的numpy数组
# seed()方法会让数据值随机一次,之后都是相同的数据
np.random.seed(1)
print(np.random.rand(3, 4))
[[4.17022005e-01 7.20324493e-01 1.14374817e-04 3.02332573e-01]
[1.46755891e-01 9.23385948e-02 1.86260211e-01 3.45560727e-01]
[3.96767474e-01 5.38816734e-01 4.19194514e-01 6.85219500e-01]]
# 构造3*4*5的均匀分布的numpy数组
print(np.random.rand(3, 4, 5))
[[[0.20445225 0.87811744 0.02738759 0.67046751 0.4173048 ]
[0.55868983 0.14038694 0.19810149 0.80074457 0.96826158]
[0.31342418 0.69232262 0.87638915 0.89460666 0.08504421]
[0.03905478 0.16983042 0.8781425  0.09834683 0.42110763]]

[[0.95788953 0.53316528 0.69187711 0.31551563 0.68650093]
[0.83462567 0.01828828 0.75014431 0.98886109 0.74816565]
[0.28044399 0.78927933 0.10322601 0.44789353 0.9085955 ]
[0.29361415 0.28777534 0.13002857 0.01936696 0.67883553]]

[[0.21162812 0.26554666 0.49157316 0.05336255 0.57411761]
[0.14672857 0.58930554 0.69975836 0.10233443 0.41405599]
[0.69440016 0.41417927 0.04995346 0.53589641 0.66379465]
[0.51488911 0.94459476 0.58655504 0.90340192 0.1374747 ]]]
# 构造3*4的正态分布的numpy数组
print(np.random.randn(3, 4))
[[ 0.30017032 -0.35224985 -1.1425182  -0.34934272]
[-0.20889423  0.58662319  0.83898341  0.93110208]
[ 0.28558733  0.88514116 -0.75439794  1.25286816]]
# 构造取值为1-5内的10个元素的ndarray数组
print(np.random.randint(1, 5, 10))
[1 1 1 2 3 1 2 1 3 4]
# 构造取值为0-1内的3*4的numpy数组
print(np.random.random_sample((3, 4)))
[[0.62169572 0.11474597 0.94948926 0.44991213]
[0.57838961 0.4081368  0.23702698 0.90337952]
[0.57367949 0.00287033 0.61714491 0.3266449 ]]
arr = np.array([1, 2, 3])
# 随机选取arr中的两个元素
print(np.random.choice(arr, size=2))
[1 3]
arr = np.random.uniform(1, 5, (2, 3))
print(arr)
[[4.72405173 3.30633687 4.35858086]
[3.49316845 2.29806999 3.91204657]]
np.random.shuffle(arr)
print(arr)
[[3.49316845 2.29806999 3.91204657]
[4.72405173 3.30633687 4.35858086]]

十、matplotlib模块

matplotlib官方文档:https://matplotlib.org/contents.html?v=20190307135750

matplotlib是一个绘图库,它可以创建常用的统计图,包括条形图、箱型图、折线图、散点图、饼图和直方图。

10、1 条形图

import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties
%matplotlib inline
font = FontProperties(fname='/Library/Fonts/Heiti.ttc')

# 修改背景为条纹
plt.style.use('ggplot')

classes = ['3班', '4班', '5班', '6班']

classes_index = range(len(classes))
print(list(classes_index))
[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()

10、2 直方图

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties
%matplotlib inline
font = FontProperties(fname='/Library/Fonts/Heiti.ttc')

# 修改背景为条纹
plt.style.use('ggplot')

mu1, mu2, sigma = 50, 100, 10
# 构造均值为50的符合正态分布的数据
x1 = mu1 + sigma * np.random.randn(10000)
print(x1)
[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()

10、3 折线图

import numpy as np
from numpy.random import randn
import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties
%matplotlib inline
font = FontProperties(fname='/Library/Fonts/Heiti.ttc')

# 修改背景为条纹
plt.style.use('ggplot')

np.random.seed(1)

# 使用numpy的累加和,保证数据取值范围不会在(0,1)内波动
plot_data1 = randn(40).cumsum()
print(plot_data1)
[ 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()

10、4 散点图+直线图

import numpy as np
from numpy.random import randn
import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties
%matplotlib inline
font = FontProperties(fname='/Library/Fonts/Heiti.ttc')

# 修改背景为条纹
plt.style.use('ggplot')

x = np.arange(1, 20, 1)
print(x)
[ 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()

10、5 饼图

import numpy as np
import matplotlib.pyplot as plt
from pylab import mpl
mpl.rcParams['font.sans-serif'] = ['SimHei']

fig, ax = plt.subplots(subplot_kw=dict(aspect="equal"))

recipe = ['优', '良', '轻度污染', '中度污染', '重度污染', '严重污染', '缺']

data = [2, 49, 21, 9, 11, 6, 2]
colors = ['lime', 'yellow', 'darkorange', 'red', 'purple', 'maroon', 'grey']
wedges, texts, texts2 = ax.pie(data,
                              wedgeprops=dict(width=0.5),
                              startangle=40,
                              colors=colors,
                              autopct='%1.0f%%',
                              pctdistance=0.8)
plt.setp(texts2, size=14, weight="bold")

bbox_props = dict(boxstyle="square,pad=0.3", fc="w", ec="k", lw=0.72)
kw = dict(xycoords='data',
        textcoords='data',
        arrowprops=dict(arrowstyle="->"),
        bbox=None,
        zorder=0,
        va="center")

for i, p in enumerate(wedges):
  ang = (p.theta2 - p.theta1) / 2. + p.theta1
  y = np.sin(np.deg2rad(ang))
  x = np.cos(np.deg2rad(ang))
  horizontalalignment = {-1: "right", 1: "left"}[int(np.sign(x))]
  connectionstyle = "angle,angleA=0,angleB={}".format(ang)
  kw["arrowprops"].update({"connectionstyle": connectionstyle})
  ax.annotate(recipe[i],
              xy=(x, y),
              xytext=(1.25 * np.sign(x), 1.3 * y),
              size=16,
              horizontalalignment=horizontalalignment,
              fontproperties=font,
              **kw)

ax.set_title("饼图示例",fontproperties=font)

plt.show()
# plt.savefig('jiaopie2.png?x-oss-process=style/watermark')

10、6 箱型图

箱型图:又称为盒须图、盒式图、盒状图或箱线图,是一种用作显示一组数据分散情况资料的统计图(在数据分析中常用在异常值检测)

包含一组数据的:最大值、最小值、中位数、上四分位数(Q3)、下四分位数(Q1)、异常值

  1. 中位数 → 一组数据平均分成两份,中间的数

  2. 上四分位数Q1 → 是将序列平均分成四份,计算(n+1)/4与(n-1)/4两种,一般使用(n+1)/4

  3. 下四分位数Q3 → 是将序列平均分成四份,计算(1+n)/4*3=6.75

  4. 内限 → T形的盒须就是内限,最大值区间Q3+1.5IQR,最小值区间Q1-1.5IQR (IQR=Q3-Q1)

  5. 外限 → T形的盒须就是内限,最大值区间Q3+3IQR,最小值区间Q1-3IQR (IQR=Q3-Q1)

  6. 异常值 → 内限之外 - 中度异常,外限之外 - 极度异常

import numpy as np
import pandas as pd
from numpy.random import randn
import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties
%matplotlib inline
font = FontProperties(fname='/Library/Fonts/Heiti.ttc')
df = pd.DataFrame(np.random.rand(10, 5), columns=['A', 'B', 'C', 'D', 'E'])
plt.figure(figsize=(10, 4))
# 创建图表、数据

f = df.boxplot(
  sym='o', # 异常点形状,参考marker
  vert=True, # 是否垂直
  whis=1.5, # IQR,默认1.5,也可以设置区间比如[5,95],代表强制上下边缘为数据95%和5%位置
  patch_artist=True, # 上下四分位框内是否填充,True为填充
  meanline=False,
  showmeans=True, # 是否有均值线及其形状
  showbox=True, # 是否显示箱线
  showcaps=True, # 是否显示边缘线
  showfliers=True, # 是否显示异常值
  notch=False, # 中间箱体是否缺口
  return_type='dict' # 返回类型为字典
)
plt.title('boxplot')

for box in f['boxes']:
  box.set(color='b', linewidth=1) # 箱体边框颜色
  box.set(facecolor='b', alpha=0.5) # 箱体内部填充颜色
for whisker in f['whiskers']:
  whisker.set(color='k', linewidth=0.5, linestyle='-')
for cap in f['caps']:
  cap.set(color='gray', linewidth=2)
for median in f['medians']:
  median.set(color='DarkBlue', linewidth=2)
for flier in f['fliers']:
  flier.set(marker='o', color='y', alpha=0.5)
# boxes, 箱线
# medians, 中位值的横线,
# whiskers, 从box到error bar之间的竖线.
# fliers, 异常值
# caps, error bar横线
# means, 均值的横线

10、7 plot函数参数

  • 线型linestyle(-,-.,--,..)

  • 点型marker(v,^,s,*,H,+,x,D,o,…)

  • 颜色color(b,g,r,y,k,w,…)

10、8 图像标注参数

  • 设置图像标题:plt.title()

  • 设置x轴名称:plt.xlabel()

  • 设置y轴名称:plt.ylabel()

  • 设置X轴范围:plt.xlim()

  • 设置Y轴范围:plt.ylim()

  • 设置X轴刻度:plt.xticks()

  • 设置Y轴刻度:plt.yticks()

  • 设置曲线图例:plt.legend()

10、9 Matplolib应用

import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties
%matplotlib inline

# 找到自己电脑的字体路径,然后修改字体路径
font = FontProperties(fname='/Library/Fonts/Heiti.ttc')

header_list = ['方程组', '函数', '导数', '微积分', '线性代数', '概率论', '统计学']
py3_df = pd.read_excel('py3.xlsx', header=None,
                      skiprows=[0, 1], names=header_list)
# 处理带有NaN的行
py3_df = py3_df.dropna(axis=0)
print(py3_df)

# 自定义映射
map_dict = {
   '不会': 0,
   '了解': 1,
   '熟悉': 2,
   '使用过': 3,
}

for header in header_list:
   py3_df[header] = py3_df[header].map(map_dict)

unable_series = (py3_df == 0).sum(axis=0)
know_series = (py3_df == 1).sum(axis=0)
familiar_series = (py3_df == 2).sum(axis=0)
use_series = (py3_df == 3).sum(axis=0)

unable_label = '不会'
know_label = '了解'
familiar_label = '熟悉'
use_label = '使用过'
for i in range(len(header_list)):
   bottom = 0

   # 描绘不会的条形图
   plt.bar(x=header_list[i], height=unable_series[i],
           width=0.60, color='r', label=unable_label)
   if unable_series[i] != 0:
       plt.text(header_list[i], bottom, s=unable_series[i],
                ha='center', va='bottom', fontsize=15, color='white')
   bottom += unable_series[i]

   # 描绘了解的条形图
   plt.bar(x=header_list[i], height=know_series[i],
           width=0.60, color='y', bottom=bottom, label=know_label)
   if know_series[i] != 0:
       plt.text(header_list[i], bottom, s=know_series[i],
                ha='center', va='bottom', fontsize=15, color='white')
   bottom += know_series[i]

   # 描绘熟悉的条形图
   plt.bar(x=header_list[i], height=familiar_series[i],
           width=0.60, color='g', bottom=bottom, label=familiar_label)
   if familiar_series[i] != 0:
       plt.text(header_list[i], bottom, s=familiar_series[i],
                ha='center', va='bottom', fontsize=15, color='white')
   bottom += familiar_series[i]

   # 描绘使用过的条形图
   plt.bar(x=header_list[i], height=use_series[i],
           width=0.60, color='b', bottom=bottom, label=use_label)
   if use_series[i] != 0:
       plt.text(header_list[i], bottom, s=use_series[i],
                ha='center', va='bottom', fontsize=15, color='white')

   unable_label = know_label = familiar_label = use_label = ''

plt.xticks(header_list, fontproperties=font)
plt.ylabel('人数', fontproperties=font)
plt.title('Python3期数学摸底可视化', fontproperties=font)
plt.legend(prop=font, loc='upper left')
plt.show()
   方程组   函数   导数        微积分       线性代数  概率论  统计学
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  使用过  使用过  使用过        使用过         不会  使用过  使用过
32   熟悉   熟悉  使用过        使用过        使用过   不会   不会
33  使用过  使用过  使用过        使用过         熟悉  使用过   熟悉
34   熟悉   熟悉   熟悉        使用过        使用过   熟悉   不会
35  使用过  使用过  使用过        使用过        使用过  使用过  使用过
36  使用过  使用过  使用过        使用过        使用过  使用过   了解
37  使用过  使用过  使用过        使用过        使用过   不会   不会
38  使用过  使用过  使用过         不会         不会   不会   不会
39  使用过  使用过   不会         不会         不会   不会   不会
40  使用过  使用过  使用过        使用过        使用过   不会   不会
41  使用过  使用过   熟悉         了解         了解   了解   不会
42  使用过  使用过  使用过         不会         不会   不会   不会
43   熟悉  使用过   了解         了解         不会   不会   不会

posted on 2019-09-23 23:04  hanyi12  阅读(242)  评论(0编辑  收藏  举报