python常用模块（一）

目录

  • time模块

    • 时间戳
    • 格式化时间
    • 结构化时间
    • 不同格式时间的转换
    • 其他用法
  • datetime模块
  • random模块
  • os模块
  • sys模块
  • json模块
  • pickle模块
  • hashlib模块
  • logging模块
  • numpy模块
    • 创建矩阵
    • 获取矩阵的行列数
    • 切割矩阵
    • 矩阵元素替换
    • 矩阵的合并
    • 通过函数创建矩阵
      • arange
      • linspace/logspace
      • zeros/ones/eye/empty
      • fromstring/fromfunction
    • 矩阵的运算
      • 普通矩阵运算
      • 常用矩阵运算函数
    • 矩阵的点乘
    • 矩阵的转置
    • 矩阵的逆
    • 矩阵其他操作
      • 最大值最小值
      • 平均值
      • 方差
      • 标准差
      • 中位数
      • 矩阵求和
      • 累加和
    • numpy.random生成随机数

time模块

time模块一般用于不同时间格式的转换。

import time

时间戳

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

time_stamp = time.time()
print(time_stamp)
print(type(time_stamp))
1560148842.1998172
<class 'float'>

格式化时间

格式化的时间字符串（format string）：格式化时间表示的是普通的字符串格式的时间。

format_time = time.strftime('%Y-%m-%d %X')
print(format_time)
print(type(format_time))
2019-06-10 14:40:27
<class 'str'>

结构化时间

结构化时间（struct time）：struct_time元组共有9个元素共9个元素，分别为（年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时）

struct_time = time.localtime()
print(f'本时区的结构化时间{struct_time}')

struct_time2 = time.gmtime()
print(f'格林威治时区的结构化时间{struct_time2}')
本时区的结构化时间time.struct_time(tm_year=2019, tm_mon=6, tm_mday=10, tm_hour=14, tm_min=46, tm_sec=38, tm_wday=0, tm_yday=161, tm_isdst=0)
格林威治时区的结构化时间time.struct_time(tm_year=2019, tm_mon=6, tm_mday=10, tm_hour=6, tm_min=46, tm_sec=38, tm_wday=0, tm_yday=161, tm_isdst=0)
# 结构化基准时间

print(time.gmtime(0))
time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=1, tm_isdst=0)
# 结构化基准时间增加一年的时间

print(time.gmtime(3600*24*365))
time.struct_time(tm_year=1971, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=4, tm_yday=1, tm_isdst=0)

不同格式时间的转换

格式化时间 <----> 结构化时间 <----> 时间戳

# 结构化时间转换其他时间

struct_time = time.localtime()

format_time = time.strftime('%Y-%m-%d %X', struct_time)
print(format_time)

print('*'*20)

stamp_time = time.mktime(struct_time)
print(stamp_time)
2019-06-10 14:59:47
********************
1560149987.0
# 其他时间转化为结构化时间

stamp_time = time.time()
struct_time = time.localtime(stamp_time)
print(struct_time)

print('*'*20)

format_time = time.strftime('%Y-%m-%d %X')
struct_time = time.strptime(format_time, '%Y-%m-%d %X')
print(struct_time)
time.struct_time(tm_year=2019, tm_mon=6, tm_mday=10, tm_hour=15, tm_min=4, tm_sec=29, tm_wday=0, tm_yday=161, tm_isdst=0)
********************
time.struct_time(tm_year=2019, tm_mon=6, tm_mday=10, tm_hour=15, tm_min=4, tm_sec=29, tm_wday=0, tm_yday=161, tm_isdst=-1)

其他用法

# 推迟指定时间，单位为秒

start = time.time()
time.sleep(3)
end = time.time()

print(end-start)
3.000153064727783

datetime模块

datetime模块一般用于时间的加减。

import datetime
# 当前时间

print(datetime.datetime.now())
2019-06-10 15:08:57.004062
print(datetime.date.fromtimestamp(time.time()))
2019-06-10
# 当前时间 + 3天
print(datetime.datetime.now() + datetime.timedelta(3))
2019-06-13 15:11:39.612122
# 当前时间  -3天
print(datetime.datetime.now()+datetime.timedelta(-3))
2019-06-07 15:13:08.785317
# 当前时间 -3小时
print(datetime.datetime.now()+datetime.timedelta(hours=-3))
2019-06-10 12:14:22.208194
# 当前时间 +30分钟
print(datetime.datetime.now()+datetime.timedelta(minutes=30))
2019-06-10 15:45:29.435875

datetime.timedelta()只能从day开始修改，默认为day

# 时间替换
now = datetime.datetime.now()
print(now.replace(day=8, year=2008, month=8, minute=8, hour=8, second=8))
2008-08-08 08:08:08.160480

random模块

random模块一般用于生成随机数。

import random
# 大于0且小于1之间的小数
print(random.random())
print(random.random())
print(random.random())
0.046596430447699344
0.35660708829222687
0.8662428083730412
# 大于等于0且小于等于3之间的整数
print(random.randint(0, 3))
print(random.randint(0, 3))
print(random.randint(0, 3))
3
0
1
# 大于等于1且小于3之间的整数
print(random.randrange(1, 3))
print(random.randrange(1, 3))
print(random.randrange(1, 3))
2
1
2
# 大于1小于3的小数
print(random.uniform(1, 3))
print(random.uniform(1, 3))
print(random.uniform(1, 3))
2.527982162768555
1.982116366291448
1.5798272480907842
# 从容器内任意选择一个元素(牢记)
lis = [1, 2, 'a', 'b', [3, 4]]
print(random.choice(lis))
print(random.choice(lis))
print(random.choice(lis))
a
[3, 4]
1
# 从容器内任意选择多个元素(牢记)
lis = [1, 2, 'a', 'b', [3, 4]]
print(random.sample(lis, 2))
print(random.sample(lis, 3))
print(random.sample(lis, 2))
[2, 'a']
[1, 2, 'a']
['a', 2]
# 打乱顺序，相当于洗牌(牢记)
lis = [1, 2, 'a', 'b', [3, 4]]
random.shuffle(lis)
print(lis)
[[3, 4], 'a', 2, 1, 'b']

os模块

os模块和操作系统交互，文件操作

import os
# 创建单个文件夹
os.mkdir('aaa')
# 删除文件夹，递归向上删除空文件夹
os.removedirs(r'E:\jupyter\aaa')
# 删除一个空文件夹
os.rmdir(r'E:\jupyter\bbb')
# 列出文件夹内所有文件名和隐藏文件名
os.listdir(r'E:\jupyter')
# 删除文件
os.remove(r'E:\jupyter\ccc')
# 重命名文件
os.rename(r'E:\jupyter\ccc', r'E:\jupyter\ddd')
# 环境变量
os.environ
# 牢记（dirname）,用在执行文件添加环境变量
res = os.path.dirname(r'E:\jupyter')  # 文件所在文件目录
print(res)
sys.path.append(res)  # 添加环境变量
E:\
# 文件是否存在
print(os.path.exists(r'E:\jupyter'))
True
# 拼接文件路径，因为不同系统的路径拼接符不同
os.path.join(r'E:\jupyter', 'aaa.json')
# (牢记)计算文件大小
print(os.path.getsize(r'E:\jupyter'))
4096
# 文件夹下所有文件夹和文件
os.walk(r'E:\jupyter')

sys模块

与Python交互

# 牢记（当使用Python file。py参数，接收参数）
print(sys.argv)
# 获取解释器的版本
print(sys.hexversion)
# 牢记（获取当前文件导入模块的路径）
print(sys.path)
# sys.stdout.write('123')  # 类似print
import sys
sys.stdout.write('123')
123
# sys.stdin.read(10)   # 类似input

json模块

序列化：保存数据（从内存到硬盘这个过程叫作序列化，这个序列化必须得规定格式），保存格式为json文件。

反序列化：把文件从硬盘中读取出来

json文件不是Python独有的，所有语言都有json，json文件可以跨平台、跨语言传输数据。

json中只能写入Python中的dict/list/str/int/float/bool/None数据类型

import json
dic = {'name': 'william'}

res = json.dumps(dic)  # 将字典存储为字符串
print(res, type(res))

res = json.loads(res)  # 取出来为字典
print(res, type(res))
{"name": "william"} <class 'str'>
{'name': 'william'} <class 'dict'>
# 重要

with open('路径', 'w', encoding='utf8') as fw:
    json.dump(dic, fw)

with open('路径', 'r', encoding='utf8') as fr:
    data = json.load(fr)

pickle模块

pickle也是序列化和反序列化，但是pickle支持Python中任意数据类型，所以不能跨平台（不同平台的函数不同）。

pickle序列化过程是以二进制形式转换。

# 传输为二进制，采用b模式

import pickle

def func():
    pass

with open('路径', 'wb') as fw:
    pickle.dump(func, fw)

with open('路径', 'rb') as fr:
    data = pickle.load(fr)

hashlib模块

对字符加密，其实就是一个自定义的字符编码表

import hashlib

m = hashlib.md5()
pwd = 'hello world'.encode('utf8')  # 二进制
m.update(pwd)
print(m.hexdigest())

pwd = '123'.encode('utf8')
m.update(pwd)
print(m.hexdigest())
5eb63bbbe01eeed093cb22bb8f5acdc3
46d7a9532282332f023c08fe25ff7105
m = hashlib.md5()
pwd = 'hello world123'.encode('utf8')
m.update(pwd)
print(m.hexdigest())
46d7a9532282332f023c08fe25ff7105

1.hash加密之后长度一样

2.hash加密的东西一样则哈希结果一样

3.如果使用同一个哈希字符编码表,不断地哈希结果会累加

# 破解密码
# 密码为下列中的一个
pwd_list = [
    'hash3714',
    'hash1313',
    'hash94139413',
    'hash123456',
    '123456hash',
    'h123ash',
]

def break_pwd(hash_pwd):
    for pwd in pwd_list:
        m = hashlib.md5()
        m.update(pwd.encode('utf8'))
        if m.hexdigest() == hash_pwd:
            return pwd

if __name__ == '__main__':
    hash_pwd = '0562b36c3c5a3925dbe3c4d32a4f2ba2'
    pwd = break_pwd(hash_pwd)
    print(pwd)
hash123456
import hmac

m = hmac.new(b'3532')  # 加盐处理

m.update('sd'.encode('utf8'))
print(m.hexdigest())

m.update(b'ds')
print(m.hexdigest())

print('*'*20)

m = hmac.new(b'123')
m.update('sd'.encode('utf8'))  # 结果不同，加盐不同
print(m.hexdigest())
fd9e2b8ec696a5e7b40535fd238d690e
df377266fb70e15f0a034615bb155db4
********************
f1049f6ddb6a7036deec4dff767288c6
import uuid

for i in range(5):
    print(uuid.uuid4())  # 永不重复，按照时间来生成的
46938db0-753c-4ec4-b633-cccc6311e309
a5452580-61fe-4e9b-bd52-b15433bf588d
97c31e7f-ed4b-4d20-afc2-d515847978a8
27c2032f-c926-40a7-b834-7f9a46b7ebf0
f5becf53-2192-456f-89ef-7f6ec0971dca

logging模块

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

V3：

1.logger 是哪个的日志

2.filter 过滤（一般不用管）

3.handler 保存在文件中，还是打印到屏幕上

4.formatter 控制日志的格式

import logging

# 1.logger 哪个的日志
logger = logging.getLogger('user_info')

# 2.filter 不用管

# 3.handler 保存在哪里，还是打印

t1 = logging.FileHandler('t1.log')  # 往文件t1中打印
t2 = logging.FileHandler('t2.log')  # 往文件t2中打印
sh = logging.StreamHandler()  # 往屏幕上打印

# 4.formatter 控制日志的格式

f1 = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
                       datefmt='%Y-%m-%d %H:%M:%S %p', )

f2 = logging.Formatter('%(asctime)s :  %(message)s',
                       datefmt='%Y-%m-%d %H:%M:%S %p', )

f3 = logging.Formatter('%(name)s %(message)s', )

# 5.formatter 绑定到handler里面去
t1.setFormatter(f1)

t2.setFormatter(f2)

sh.setFormatter(f3)

# handler 绑定到logger里面去
logger.addHandler(t1)

logger.addHandler(t2)

logger.addHandler(sh)

# 设置打印级别
logger.setLevel(10)  # 控制着全部，先走全部，再走单个，如果不设置，默认30，必须设置
t1.setLevel(20)
t2.setLevel(30)
sh.setLevel(40)

# 测试

logger.info('123')
logger.debug('123')
logger.warning('123')
logger.error('123')
logger.critical('123')
# 日志配置文件

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
# C:\Users\oldboy\Desktop\atm\log
logfile_dir = os.path.join(logfile_dir, 'log')

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

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

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

# 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!')  # 记录该文件的运行状态

if __name__ == '__main__':
    load_my_logging_cfg()

numpy模块

numpy库有两个作用：

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

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

创建矩阵

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

import numpy as np
# 创建一维的nddarray对象
arr = np.array([1, 2, 3])
print(arr)
print(type(arr))
[1 2 3]
<class 'numpy.ndarray'>
# 创建二维的ndarray对象
arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr)
[[1 2 3]
 [4 5 6]]
# 创建三维的ndarray对象
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]]]

获取矩阵的行列数

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

切割矩阵

切分矩阵类似于列表的切割，但是与列表的切割不同的是，矩阵的切割涉及到行和列的切割，但是两者的切割方式都是从索引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, :])
[1 2 3 4]
# 取第一列
print(arr[:, :1])
[[1]
 [5]
 [9]]
# 取出第一列所有元素
print(arr[:, 0])
[1 5 9]
# 取大于5的元素
print(arr[arr > 5])
[ 6  7  8  9 10 11 12]
print(arr > 5)
[[False False False False]
 [False  True  True  True]
 [ True  True  True  True]]

矩阵元素替换

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

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的元素改为0
arr2 = arr.copy()
arr2[arr2 > 5] = 0
print(arr2)
[[1 2 3 4]
 [5 0 0 0]
 [0 0 0 0]]
# 矩阵清零
arr3 = arr.copy()
arr3[:, :] = 0
print(arr3)
[[0 0 0 0]
 [0 0 0 0]
 [0 0 0 0]]

矩阵的合并

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]]
# 合并两个矩阵的行，矩阵行应该相同，h为horizontal水平的
print(np.hstack((arr1, arr2)))
[[ 1  2  7  8]
 [ 3  4  9 10]
 [ 5  6 11 12]]
# 合并两个矩阵的列，矩阵的列应该相同，v为vertical垂直的
print(np.vstack((arr1, arr2)))
[[ 1  2]
 [ 3  4]
 [ 5  6]
 [ 7  8]
 [ 9 10]
 [11 12]]
# axis = 1,合并两个矩阵的行， axis= 0，合并矩阵的列
print(np.concatenate((arr1, arr2), axis=1))
print('*'*20)
print(np.concatenate((arr1, arr2), axis=0))
[[ 1  2  7  8]
 [ 3  4  9 10]
 [ 5  6 11 12]]
********************
[[ 1  2]
 [ 3  4]
 [ 5  6]
 [ 7  8]
 [ 9 10]
 [11 12]]

通过函数创建矩阵

arange

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

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]

zeros/ones/eye/empty

# 构造3*4的全0矩阵
print(np.zeros((3, 4)))
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]
# 构造3*4的全1矩阵
print(np.ones((3, 4)))
[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]
# 构造3个主元的单位矩阵
print(np.eye(3))
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
# 构造一个4*4的随机矩阵，里面的元素是随机生成的
print(np.empty((4, 4)))
[[4.67296746e-307 1.69121096e-306 8.90108313e-307 8.34441742e-308]
 [1.78022342e-306 6.23058028e-307 9.79107872e-307 6.89807188e-307]
 [7.56594375e-307 6.23060065e-307 1.78021527e-306 8.34454050e-308]
 [1.11261027e-306 1.15706896e-306 1.33512173e-306 1.33504432e-306]]

fromstring/fromfunction

# fromstring通过对字符串的字符编码所对应ASCII编码的位置，生成一个ndarray对象
s = 'abcdef'
# np.int8表示一个字符的字节数为8
print(np.fromstring(s, dtype=np.int8))  # [ 97  98  99 100 101 102]
def func(i, j):
    """其中i为矩阵的行，j为矩阵的列"""
    return i*j

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

矩阵的运算

普通矩阵运算

运算符       说明
  +     两个矩阵对应元素相加
  -     两个矩阵对应元素相减
  *     两个矩阵对应元素相乘
  /     两个矩阵对应元素相除，如果都是整数则取商
  %     两个矩阵对应元素相除后取余数
  **n    单个矩阵每个元素都取n次方，如**2：每个元素都取平方
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]]
print(arr1+arr2)
[[ 8 10]
 [12 14]
 [16 18]]
print(arr1**2)
[[ 1  4]
 [ 9 16]
 [25 36]]

常用矩阵运算函数

 矩阵函数               详解
np.sin(arr)       对矩阵arr中每个元素取正弦，sin(x)
np.cos(arr)       对矩阵arr中每个元素取余弦，cos(x)
np.tan(arr)       对矩阵arr中每个元素取正切，tan(x)
np.arcsin(arr)     对矩阵arr中每个元素取反正弦，arcsin(x)
np.arccos(arr)     对矩阵arr中每个元素取反余弦，arccos(x)
np.arctan(arr)     对矩阵arr中每个元素取反正切，arctan(x)
np.exp(arr)       对矩阵arr中每个元素取指数函数
np.sqrt(arr)         对矩阵arr中每个元素开根号
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(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]]
# 对矩阵的所有元素开根号
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]]

矩阵的点乘

矩阵点乘必须满足第一个矩阵的列数等于第二个矩阵的行数，即m?n?n?m=m?m。

arr1 = np.array([[1, 2, 3],  [4, 5, 6]])
print(arr1.shape)
print(arr1)
(2, 3)
[[1 2 3]
 [4 5 6]]
arr2 = np.array([[7, 8], [9, 10], [11, 12]])
print(arr2.shape)
print(arr2)
(3, 2)
[[ 7  8]
 [ 9 10]
 [11 12]]
print(arr1.dot(arr2))
[[ 58  64]
 [139 154]]

矩阵的转置

矩阵的转置，相当于矩阵的行与列互换。

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]]

矩阵的逆

矩阵行和列相同时，矩阵才可逆。

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr)
[[1 2 3]
 [4 5 6]
 [7 8 9]]
print(np.linalg.inv(arr))
[[-4.50359963e+15  9.00719925e+15 -4.50359963e+15]
 [ 9.00719925e+15 -1.80143985e+16  9.00719925e+15]
 [-4.50359963e+15  9.00719925e+15 -4.50359963e+15]]
# 单位矩阵的逆是单位矩阵本身
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.]]

矩阵其他操作

最大值最小值

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

平均值

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

方差

方差公式为 mean(|x?x.mean()|^2) 其中x为矩阵。

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

标准差

标准差公式为
sqrt(mean(|x?x.mean()|^2)) = sqrt(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]]
# 获取矩阵所有元素的标准差
print(arr.std())
2.581988897471611
# 获取矩阵每一列的标准差
print(arr.std(axis=0))
[2.44948974 2.44948974 2.44948974]
# 获取矩阵每一行的标准差
print(arr.std(axis=1))
[0.81649658 0.81649658 0.81649658]

中位数

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

矩阵求和

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

累加和

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]

numpy.random生成随机数

函数名称 函数功能 参数说明
rand(d0,d1,?,dn) 产生[0,1)内的均匀分布的随机数 dn为第n维数据的维度
randn(d0,d1,?,dn) 产生标准正态分布随机数 dn为第n维数据的维度
randint(low[, high, size, dtype]) 产生随机整数 low:最小值；high:最大值；size:数据个数
random_sample([size]) 在[0,1)内产生随机数 size为随机数的shape，可以为元祖或者列表
choice(a[, size]) 从arr中随机选择指定数据 arr为1维数组；size为数据形状 
# 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的均匀分布的矩阵
# 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的均匀分布的矩阵
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的正态分布的矩阵
print(np.random.randn(3, 4))
[[ 0.31563495 -2.02220122 -0.30620401  0.82797464]
 [ 0.23009474  0.76201118 -0.22232814 -0.20075807]
 [ 0.18656139  0.41005165  0.19829972  0.11900865]]
# 构造取值为1-5内的元素的ndarray数组
print(np.random.randint(1, 5, 10))
[2 3 4 2 2 1 2 1 2 1]
# 构造取值为0-1内的3*4的矩阵
print(np.random.random_sample((3, 4)))
[[0.24621107 0.86002795 0.53883106 0.55282198]
 [0.84203089 0.12417332 0.27918368 0.58575927]
 [0.96959575 0.56103022 0.01864729 0.80063267]]
arr = np.array([1, 2, 3])
# 随机选取arr中的两个元素
print(np.random.choice(arr, size=2))
[2 2]

原文地址：https://www.cnblogs.com/WilliamKong94/p/11047806.html

时间： 2024-11-10 14:06:57

python常用模块（一）的相关文章

python——常用模块

time.asctime(time.localtime(1234324422)) python--常用模块 1 什么是模块: 模块就是py文件 2 import time #导入时间模块 在Python中,通常有这三种方式来表示时间:时间戳.元组(struct_time).格式化的时间字符串: (1)时间戳(timestamp) :通常来说,时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量.我们运行"type(time.time())",返回的是float类型.

实战篇一 python常用模块和库介绍

# [email protected] coding: utf-8 [email protected] -- Python 常用模块和库介绍 第一部分:json模块介绍 import json 将一个Python数据结构转换为JSON: dict_ = {1:2, 3:4, "55":"66"} # test json.dumps print type(dict_), dict_ json_str = json.dumps(dict_) print "js

python——常用模块2

python--常用模块2 1 logging模块 1.1 函数式简单配置 import logging logging.debug("debug message") logging.info("info message") logging.warning("warning message") logging.error("error message") logging.critical('critical message')

Python常用模块-随机数模块（random）

Python常用模块-随机数模块(random) 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.常用方法举例 1 #!/usr/bin/env python 2 #_*_coding:utf-8_*_ 3 #@author :yinzhengjie 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7

Python常用模块-摘要算法（hashlib）

Python常用模块-摘要算法(hashlib) 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.MD5算法参数详解 1.十六进制md5算法摘要 1 #!/usr/bin/env python 2 #_*_coding:utf-8_*_ 3 #@author :yinzhengjie 4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%

python 常用模块 time random os模块 sys模块 json &amp; pickle shelve模块 xml模块 configparser hashlib subprocess logging re正则

python 常用模块 time random os模块 sys模块 json & pickle shelve模块 xml模块 configparser hashlib  subprocess logging re正则 转自老男孩老师Yuan:http://www.cnblogs.com/yuanchenqi/articles/5732581.html 模块&包(* * * * *) 模块(modue)的概念: 在计算机程序的开发过程中,随着程序代码越写越多,在一个文件里代码就会越来越长,

python常用模块之time&amp;datetime模块

python常用模块之time&datetime模块 在平常的代码中,我们经常要与时间打交道.在python中,与时间处理有关的模块就包括:time和datetime,下面分别来介绍: 在开始之前,首先要说明有以下几种方式来表示时间: 1.时间戳 2.格式化的时间字符串(时间对象) 3.元组(struct_time)共九个元素,由于python的time模块实现主要调用C库,所以各个平台可能不同 几个定义 UTC(Coordinated Universal Time,世界协调时)亦即格林威治天文

Python常用模块——系统调用os模块

Python常用模块--系统调用os模块 OS模块 os模块提供了很多允许你的程序与操作系统直接交互的功能. 得到当前工作目录,即当前Python脚本工作的目录路径: os.getcwd() 返回指定目录下的所有文件和目录名:os.listdir() 函数用来删除一个文件:os.remove() 删除多个目录:os.removedirs(r"c:\python") 检验给出的路径是否是一个文件:os.path.isfile() 检验给出的路径是否是一个目录:os.path.isdir(

Python常用模块——系统调用sys模块

Python常用模块--系统调用sys模块 sys 模块 sys.argv 命令行参数List,第一个元素是程序本身路径 sys.exit(n) 退出程序,正常退出时exit(0) sys.version 获取Python解释程序的版本信息 sys.maxint 最大的Int值 sys.path 返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值 sys.platform 返回操作系统平台名称 sys.stdout.write('please:') #标准输出 , 引出进度条的例子

Python常用模块——模块介绍与导入

Python常用模块--模块介绍与导入 一.什么是模块? 在计算机程序的开发过程中,随着程序代码越写越多,在一个文件里代码就会越来越长,越来越不容易维护. 为了编写可维护的代码,我们把很多函数分组,分别放到不同的文件里,这样,每个文件包含的代码就相对较少了,很多编程语言都采用这种组织代码的形式. 在Python中,以个.py文件就可以称之为一个模块(Module). 二.使用模块有什么好处? 1.最大的好处是大大提高了代码的可维护性.其次,编写代码不必从零开始.当一个模块编写完毕,就可以被其他地